ELK/Furnace/FurnaceUI/Views/Editors/RecipeCommandViewModel.cs

using Caliburn.Micro;
using Caliburn.Micro.Core;
using FurnaceUI.Common;
using FurnaceUI.Models;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using OpenSEMI.ClientBase;
using RecipeEditorLib.RecipeModel.Params;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;

namespace FurnaceUI.Views.Editors
{
    public class RecipeCommandViewModel : FurnaceUIViewModelBase
    {

        public bool NoneBtnVisibility { get; set; } = true;
        public bool ResetBtnVisibility { get; set; } = true;
        public bool JumpStepBtnVisibility { get; set; } = true;
        public bool LoopStepBtnVisibility { get; set; } = true;
        public bool EndBtnVisibility { get; set; } = true;
        public bool HoldBtnVisibility { get; set; } = true;
        public bool BuzzerBtnVisibility { get; set; } = true;
        public bool CallSubRecipeBtnVisibility { get; set; } = true;
        public bool LeakCheck1BtnVisibility { get; set; } = true;
        public bool LeakCheck2BtnVisibility { get; set; } = true;
        public bool LeakCheck3BtnVisibility { get; set; } = true;
        private string _JumpStepText;
        public string JumpStepText
        {
            get => _JumpStepText;
            set
            {
                _JumpStepText = value;
                NotifyOfPropertyChange(nameof(JumpStepText));
            }
        }
        private bool _JumpStepTextVisibility;
        public bool JumpStepTextVisibility
        {
            get => _JumpStepTextVisibility;
            set
            {
                _JumpStepTextVisibility = value;
                NotifyOfPropertyChange(nameof(JumpStepTextVisibility));
            }
        }
        public Step SelectedRecipeStep { get; set; }

        public RecipeDataBase RecipeData { get; set; }
        public ObservableCollection<ShowStep> LoopStepNames { get; set; }
        public ObservableCollection<ShowStep> JumpStepNames { get; set; }
        private RecipeCommandView _view;
        private string selectRecipeCommand;
        public string SelectRecipeCommand
        {
            get { return selectRecipeCommand; }
            set { selectRecipeCommand = value; this.NotifyOfPropertyChange(nameof(SelectRecipeCommand)); }
        }
        public bool IsEnable => CGlobal.RecipeProcessEditViewEnable;//是否是View模式

        private Visibility _rdoSubRecipeVisibility = Visibility.Visible;
        public Visibility RdoSubRecipeVisibility
        {
            get => _rdoSubRecipeVisibility;
            set
            {
                _rdoSubRecipeVisibility = value;
                NotifyOfPropertyChange(nameof(RdoSubRecipeVisibility));
            }
        }

        private Visibility _rdoLoopVisibility = Visibility.Hidden;
        public Visibility RdoLoopVisibility
        {
            get => _rdoLoopVisibility;
            set
            {
                _rdoLoopVisibility = value;
                NotifyOfPropertyChange(nameof(RdoLoopVisibility));
            }
        }

        private string _SubRecipeLoopCount;
        public string SubRecipeLoopCount
        {
            get => _SubRecipeLoopCount;
            set
            {
                _SubRecipeLoopCount = value;
                NotifyOfPropertyChange(nameof(SubRecipeLoopCount));
            }
        }

        private string _SubRecipeTableIndex;
        public string SubRecipeTableIndex
        {
            get => _SubRecipeTableIndex;
            set
            {
                _SubRecipeTableIndex = value;
                NotifyOfPropertyChange(nameof(SubRecipeTableIndex));
            }
        }

        private bool _IsSubRecipePage;

        public bool IsSubRecipePage
        {
            get { return _IsSubRecipePage; }
            set { _IsSubRecipePage = value; this.NotifyOfPropertyChange(nameof(IsSubRecipePage)); }
        }
        private string _loopStepStr = "";

        public string LoopStepStr
        {
            get => _loopStepStr;
            set
            {
                _loopStepStr = value;
                NotifyOfPropertyChange(nameof(LoopStepStr));
            }
        }

        private int _loopCount = 1;

        public int LoopCount
        {
            get => _loopCount;
            set
            {
                _loopCount = value;
                NotifyOfPropertyChange(nameof(LoopCount));
            }
        }

        protected override void OnInitialize()
        {
            base.OnInitialize();
            InitControl();
            SetBtnVisibility();
            SetJumpStepText();
            SetSubRecipeReview();
        }
        /// <summary>
        /// 初始化按钮 是否被选中 
        /// </summary>
        private void InitControl()
        {
            if (string.IsNullOrEmpty(SelectRecipeCommand))
                return;
            _view = ((GetView() as Window).Content) as RecipeCommandView;
            string key = SelectRecipeCommand.Split(':')[0];
            Dictionary<string, string> dicNames = new Dictionary<string, string>() {
                { "CallSubRecipe","CallSubRecipe"},
                { "Jump","JumpStep"},
            };
            string nameKey = dicNames.ContainsKey(key) ? dicNames[key] : SelectRecipeCommand;
            if (SelectRecipeCommand.Contains("LOOP"))
            {
                nameKey = "LoopStep";
                LoopStepAnalyse(SelectRecipeCommand);
                RdoLoopVisibility = Visibility.Visible;
            }
            if (SelectRecipeCommand.StartsWith("CALL"))
            {
                nameKey = "CallSubRecipe";
            }
            var control = _view.FindName(nameKey);
            if (control is null)
                return;
            RadioButton radioButton = control as RadioButton;
            radioButton.IsChecked = true;
            //SetCommand(radioButton);
        }

        private void LoopStepAnalyse(string value, bool noChangedCount = true)
        {
            if (value.Contains("[") && value.Contains("]"))
            {
                if (value.IndexOf('[') < value.IndexOf(']') && noChangedCount)
                {
                    string countStr = new string(value.Skip(value.IndexOf('[') + 1).Take(value.IndexOf(']') - value.IndexOf('[') - 1).ToArray());
                    int tempCount = 0;
                    int.TryParse(countStr, out tempCount);
                    LoopCount = tempCount;
                }
                if (value.LastIndexOf('[') < value.LastIndexOf(']'))
                {
                    LoopStepStr = new string(value.Skip(value.LastIndexOf('[') + 1).Take(value.LastIndexOf(']') - value.LastIndexOf('[') - 1).ToArray());
                }
            }
        }
        public void ShowRecipeLoopSetView()
        {
            var windowManager = IoC.Get<IWindowManager>();
            RecipeLoopSetViewModel recipeLoopSetViewModel = new RecipeLoopSetViewModel();
            recipeLoopSetViewModel.StepNames = JumpStepNames;
            if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeLoopSetViewModel, null, "Jump"))
            {
                SelectRecipeCommand = "Jump:" + recipeLoopSetViewModel.SelectedText;
                JumpStepText = recipeLoopSetViewModel.SelectedText.Replace("[", string.Empty).Replace("]", string.Empty);
                JumpStepTextVisibility = true;
            }
            else
            {
                ((Window)GetView()).DialogResult = false;
                return;
            }
        }

        private void SetJumpStepText()
        {
            if (string.IsNullOrEmpty(SelectRecipeCommand) || !SelectRecipeCommand.Contains("Jump:"))
            {
                JumpStepText = string.Empty;
                JumpStepTextVisibility = false;
            }
            else
            {
                JumpStepText = SelectRecipeCommand.Replace("Jump:", string.Empty).Replace("[", string.Empty).Replace("]", string.Empty);
                JumpStepTextVisibility = true;
            }

        }
        private void SetSubRecipeReview()
        {

            if (string.IsNullOrEmpty(SelectRecipeCommand) || !SelectRecipeCommand.Contains("CALL"))
            {
                SubRecipeTableIndex = string.Empty;
            }
            else
            {
                var callSubRecipeText = SelectRecipeCommand.Replace("CALL", string.Empty).Replace("[", string.Empty).Replace("]", string.Empty);
                if (string.IsNullOrEmpty(callSubRecipeText))
                {
                    return;
                }
                var callSubRecipeStrs = callSubRecipeText.Split('*');
                SubRecipeTableIndex = callSubRecipeStrs.LastOrDefault();
                SubRecipeLoopCount = callSubRecipeStrs.FirstOrDefault();
                IsSubRecipePage = true;
            }
        }
        public void SetCommand(RadioButton radioButton)
        {
            IsSubRecipePage = false;

            var windowManager = IoC.Get<IWindowManager>();
            string commandContent = radioButton.Content as string;
            switch (commandContent)
            {
                case "Call Sub Recipe":
                    JumpStepTextVisibility = false;
                    var strs = SelectRecipeCommand.Split(':');
                    if (strs.Length > 1 && SelectRecipeCommand.Contains("CALL"))
                    {
                        var callSubRecipeText = SelectRecipeCommand.Replace("CALL", string.Empty).Replace("[", string.Empty).Replace("]", string.Empty);
                        if (string.IsNullOrEmpty(callSubRecipeText))
                        {
                            return;
                        }
                        var callSubRecipeStrs = callSubRecipeText.Split('*');
                        SubRecipeTableIndex = callSubRecipeStrs.LastOrDefault();
                        SubRecipeLoopCount = callSubRecipeStrs.FirstOrDefault();
                    }
                    IsSubRecipePage = true;
                    break;
                case "Jump Step":
                    RecipeLoopSetViewModel recipeLoopSetViewModel = new RecipeLoopSetViewModel();
                    recipeLoopSetViewModel.StepNames = JumpStepNames;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeLoopSetViewModel, null, "Jump"))
                    {
                        SelectRecipeCommand = "Jump:" + recipeLoopSetViewModel.SelectedText;
                        JumpStepText = recipeLoopSetViewModel.SelectedText.TrimStart('[').TrimEnd(']');
                        JumpStepTextVisibility = true;
                    }
                    else
                    {
                        ((Window)GetView()).DialogResult = false;
                        return;
                    }
                    break;
                case "Loop Step":
                    recipeLoopSetViewModel = new RecipeLoopSetViewModel();
                    recipeLoopSetViewModel.StepNames = LoopStepNames;
                    recipeLoopSetViewModel.LoopCountVisibility = Visibility.Hidden;
                    if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeLoopSetViewModel, null, "Loop"))
                    {
                        SelectRecipeCommand = "LOOP" + recipeLoopSetViewModel.SelectedText;
                        LoopStepAnalyse(SelectRecipeCommand, false);
                    }
                    else
                    {
                        ((Window)GetView()).DialogResult = false;
                        return;
                    }
                    break;
                default:
                    SelectRecipeCommand = commandContent;
                    break;
            }
            if (SelectRecipeCommand.Contains("CallSubRecipe"))
            {
                RdoSubRecipeVisibility = Visibility.Visible;
                RdoLoopVisibility = Visibility.Hidden;
            }
            else if (SelectRecipeCommand.Contains("LOOP"))
            {
                RdoSubRecipeVisibility = Visibility.Hidden;
                RdoLoopVisibility = Visibility.Visible;
            }
            else
            {
                RdoSubRecipeVisibility = Visibility.Visible;
                RdoLoopVisibility = Visibility.Hidden;
            }
        }
        /// <summary>
        /// 根据Recipe类型设置Command 弹窗的按钮展示
        /// </summary>
        private void SetBtnVisibility()
        {
            if (null == RecipeData || string.IsNullOrEmpty(RecipeData.PrefixPath))
            {
                return;
            }

            var recipeType = RecipeData.PrefixPath.Split('\\').LastOrDefault();
            recipeType = recipeType.ToLower();
            if ("process".Equals(recipeType) && (SelectedRecipeStep.StepNo.Equals(0)|| SelectedRecipeStep.StepNo.Equals(RecipeData.Steps.Count-1)))
            {
                ResetBtnVisibility = false;

                JumpStepBtnVisibility = false;
                LoopStepBtnVisibility = false;
                EndBtnVisibility = false;
                HoldBtnVisibility = false;
                BuzzerBtnVisibility = false;
                LeakCheck1BtnVisibility = false;
                LeakCheck2BtnVisibility = false;
                LeakCheck3BtnVisibility = false;
            }
            if ("sub".Equals(recipeType))
            {
                CallSubRecipeBtnVisibility = false;
                if (SelectedRecipeStep.StepNo.Equals(1))
                {
                    LoopStepBtnVisibility = false;
                }
                else
                {
                    LoopStepBtnVisibility = true;
                }
            }

            if ("alarm".Equals(recipeType))
            {
                CallSubRecipeBtnVisibility = false;
                LeakCheck1BtnVisibility = false;
                LeakCheck2BtnVisibility = false;
                LeakCheck3BtnVisibility = false;
                if (SelectedRecipeStep.StepNo.Equals(1))
                {
                    LoopStepBtnVisibility = false;
                }
                else
                {
                    LoopStepBtnVisibility = true;
                }
            }

            if ("abort".Equals(recipeType))
            {
                ResetBtnVisibility = false;
                EndBtnVisibility = false;
                BuzzerBtnVisibility = false;
                CallSubRecipeBtnVisibility = false;
                if (SelectedRecipeStep.StepNo.Equals(1))
                {
                    LoopStepBtnVisibility = false;
                }
                else
                {
                    LoopStepBtnVisibility = true;
                }
            }
            if ("idle".Equals(recipeType))
            {

                ResetBtnVisibility = false;
                EndBtnVisibility = false;
                HoldBtnVisibility = false;
                BuzzerBtnVisibility = false;
                CallSubRecipeBtnVisibility = false;
                LeakCheck1BtnVisibility = false;
                LeakCheck2BtnVisibility = false;
                LeakCheck3BtnVisibility = false;
                if (SelectedRecipeStep.StepNo.Equals(1))
                {
                    LoopStepBtnVisibility = false;
                }
                else
                {
                    LoopStepBtnVisibility = true;
                }
            }

        }

        public void LoopStepSelectChick(Button btn)
        {
            var windowManager = IoC.Get<IWindowManager>();
            RecipeLoopSetViewModel recipeLoopSetViewModel = new RecipeLoopSetViewModel();
            recipeLoopSetViewModel.StepNames = LoopStepNames;
            recipeLoopSetViewModel.LoopCountVisibility = Visibility.Hidden;
            if ((bool)(windowManager as WindowManager)?.ShowDialogWithTitle(recipeLoopSetViewModel, null, "Loop"))
            {
                SelectRecipeCommand = "LOOP" + recipeLoopSetViewModel.SelectedText;
                LoopStepAnalyse(SelectRecipeCommand, false);
            }
            else
            {
                return;
            }

        }

        public void SelectTable()
        {
            Combination combination = new Combination(RecipeData.ConfigItems);
           
            if (string.IsNullOrEmpty(combination.SubRecipePath))
            {
                DialogBox.ShowError("Please select sub recipe first!");
                return;
            }
            var retRecipe = RecipeTableSelect.ShowDialog($"Furnace\\sub", combination.SubRecipePath, false);
            if (!string.IsNullOrEmpty(retRecipe))
            {
                SubRecipeTableIndex = retRecipe;
            }
        }
        public void RecipeCommandClose()
        {
            if (IsSubRecipePage && SubRecipeLoopCount != null && SubRecipeTableIndex != null)
                SelectRecipeCommand = $"CALL[{SubRecipeLoopCount}]*[{SubRecipeTableIndex}]";
            if (_view != null && (bool)_view.LoopStep.IsChecked)
            {
                SelectRecipeCommand = $"LOOP[{LoopCount}]*[{LoopStepStr}]";
            }
            ((Window)GetView()).DialogResult = true;
        }
    }
}