ELK/Furnace/FurnaceUI/Views/Recipes/RecipesCompareTwoViewModel.cs

using Aitex.Core.RT.Log;
using Caliburn.Micro;
using FurnaceUI.Client.Dialog;
using FurnaceUI.Views.Editors;
using MECF.Framework.Common.CommonData;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.UI.Client.CenterViews.Editors;
using MECF.Framework.UI.Client.CenterViews.Editors.Recipe;
using MECF.Framework.UI.Client.CenterViews.Editors.Sequence;
using MECF.Framework.UI.Client.ClientBase;
using OpenSEMI.ClientBase;
using RecipeEditorLib.RecipeModel.Params;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text.RegularExpressions;
using System.Windows;
using System.Windows.Controls;
using System.Xml;

namespace FurnaceUI.Views.Recipes
{
    public class TwoStepDataItem : CompareItem
    {
        public string AStepNumber { get; set; }

        private string _aStepName;
        public string AStepName
        {
            get => _aStepName;
            set
            {
                _aStepName = value;
                InvokePropertyChanged("AStepName");
            }
        }

        public string BStepNumber { get; set; }
        public string BStepName { get; set; }
    }

    public class TwoParamDataItem : CompareItem
    {

        private string _paramName;
        public string ParamName
        {
            get => _paramName;
            set
            {
                _paramName = value;
                InvokePropertyChanged("_paramName");
            }
        }

        private string _aParamValue;
        public string AParamValue
        {
            get => _aParamValue;
            set
            {
                _aParamValue = value;
                InvokePropertyChanged("AParamValue");
            }
        }

        private string _bParamValue;

        public string BParamValue
        {
            get => _bParamValue;
            set
            {
                _bParamValue = value;
                InvokePropertyChanged("BParamValue");
            }
        }
    }

    public class TableDataItem : CompareItem
    {
        public string TableIndex { get; set; }
        public string TableName { get; set; }
        public string EndStatus { get; set; }
    }

    public class TwoTableDataItem : CompareItem
    {
        public int Index { get; set; }

        public string ATableName { get; set; }

        public string BTableName { get; set; }
    }

    public class RecipesCompareTwoViewModel : ModuleUiViewModelBase
    {
        private string _module = "PM1";
        public ObservableCollection<ProcessTypeFileItem> ProcessTypeFileList { get; set; }

        public ObservableCollection<string> ChamberType { get; set; }
        public ObservableCollection<string> RecipeProcessType { get; set; }
        public int ChamberTypeIndexSelection { get; set; }
        public int _processTypeIndexSelection;
        public int ProcessTypeIndexSelection
        {
            get { return _processTypeIndexSelection; }
            set { _processTypeIndexSelection = value; NotifyOfPropertyChange("ProcessTypeIndexSelection"); }
        }

        public string CurrentChamberType
        {
            get
            {
                return ChamberType[ChamberTypeIndexSelection];
            }
        }

        public string SelectedRecipeType { get; set; }

        private string _currentProcessType;
        public string CurrentProcessType
        {
            get
            {
                if (ProcessTypeIndexSelection < 0)
                    ProcessTypeIndexSelection = 0;

                if (ProcessTypeFileList.Count == 0)
                    return "Process";

                return ProcessTypeFileList[ProcessTypeIndexSelection].ProcessType;
            }
            set { _currentProcessType = CurrentProcessType; NotifyOfPropertyChange("CurrentProcessType"); }
        }
        public ObservableCollection<TwoStepDataItem> StepList { get; set; } = new ObservableCollection<TwoStepDataItem>();

        public ObservableCollection<TwoParamDataItem> ParamList { get; set; } = new ObservableCollection<TwoParamDataItem>();
        //-------------------------A Properties
        public ObservableCollection<StepDataItem> StepListA { get; set; }


        public ObservableCollection<ParamDataItem> ParamListA { get; set; }
        public ObservableCollection<LineDataItem> WholeListA { get; set; }
        public string RecipeA { get; set; }
        private XmlDocument _domA = new XmlDocument();
        private string _pathPrefixA;
        private Dictionary<string, ObservableCollection<ParamDataItem>> _mapStepParamA = new Dictionary<string, ObservableCollection<ParamDataItem>>();

        private Dictionary<TableDataItem, Dictionary<string, ObservableCollection<ParamDataItem>>> _mapTableStepParamA = new Dictionary<TableDataItem, Dictionary<string, ObservableCollection<ParamDataItem>>>();

        private Dictionary<string, LineDataItem> _mapLineTextA = new Dictionary<string, LineDataItem>();

        private List<string> BackInnerXmlTextA = new List<string>();

        private bool _isChangedA { get; set; }

        public bool EnableButtonRemoveA
        {
            get { return !string.IsNullOrEmpty(RecipeA); }
        }
        public bool EnableButtonUndoA
        {
            get { return false; }
        }
        public bool EnableButtonSaveA
        {
            get { return false; }
        }

        private Visibility _paramVisibility;

        public Visibility ParamVisibility
        {
            get => _paramVisibility;
            set
            {
                _paramVisibility = value;
                NotifyOfPropertyChange(nameof(ParamVisibility));
            }
        }

        private TwoStepDataItem _stepSelection;
        public TwoStepDataItem StepSelection
        {
            get
            {
                return _stepSelection;
            }
            set
            {
                if (!BtnTableIsEnabled)
                {
                    SyncStepSelection(value);
                }
                else
                {
                    SyncTableStepSelection(value);
                }
                SyncShowDiffParams(_isShowDiffParams);
                _stepSelection = value;
                ParamSelection = null;
                NotifyOfPropertyChange(nameof(StepSelection));
            }
        }

        private TwoParamDataItem _paramSelection;
        public TwoParamDataItem ParamSelection
        {
            get
            {
                return _paramSelection;
            }
            set
            {
                _paramSelection = value;
                if (value == null)
                {
                    ParamVisibility = Visibility.Hidden;
                }
                else
                {
                    ParamVisibility = Visibility.Visible;
                }
                NotifyOfPropertyChange(nameof(ParamSelection));
            }
        }

        //private ParamDataItem _paramSelectionA;
        //public ParamDataItem ParamSelectionA
        //{
        //    get
        //    {
        //        return _paramSelectionA;
        //    }
        //    set
        //    {
        //        SyncParamSelection(value, false);
        //        _paramSelectionA = value;
        //    }
        //}

        private LineDataItem _lineSelectionA;
        public LineDataItem LineSelectionA
        {
            get
            {
                return _lineSelectionA;
            }
            set
            {
                SyncLineSelection(value, false);
                _lineSelectionA = value;
            }
        }

        //-------------------------B Properties-------------------------------------------------------------
        public ObservableCollection<StepDataItem> StepListB { get; set; }
        public ObservableCollection<ParamDataItem> ParamListB { get; set; }
        public ObservableCollection<LineDataItem> WholeListB { get; set; }
        public string RecipeB { get; set; }
        private XmlDocument _domB = new XmlDocument();
        private string _pathPrefixB;
        private Dictionary<string, ObservableCollection<ParamDataItem>> _mapStepParamB = new Dictionary<string, ObservableCollection<ParamDataItem>>();

        private Dictionary<TableDataItem, Dictionary<string, ObservableCollection<ParamDataItem>>> _mapTableStepParamB = new Dictionary<TableDataItem, Dictionary<string, ObservableCollection<ParamDataItem>>>();
        private Dictionary<string, LineDataItem> _mapLineTextB = new Dictionary<string, LineDataItem>();

        private List<string> BackInnerXmlTextB = new List<string>();
        private string BaseTextB = "";

        private bool _isChangedB { get; set; }

        public bool EnableButtonRemoveB
        {
            get { return !string.IsNullOrEmpty(RecipeB); }
        }
        public bool EnableButtonUndoB
        {
            get { return false; }
        }
        public bool EnableButtonSaveB
        {
            get { return false; }
        }

        private ParamDataItem _paramSelectionB;
        public ParamDataItem ParamSelectionB
        {
            get
            {
                return _paramSelectionB;
            }
            set
            {
                SyncParamSelection(value, true);
                _paramSelectionB = value;
            }
        }

        private LineDataItem _lineSelectionB;
        public LineDataItem LineSelectionB
        {
            get
            {
                return _lineSelectionB;
            }
            set
            {
                SyncLineSelection(value, true);
                _lineSelectionB = value;
            }
        }

        private bool _isCurrentSelected = true;

        public bool IsCurrentSelected
        {
            get => _isCurrentSelected;
            set
            {
                _isCurrentSelected = value;
                NotifyOfPropertyChange(nameof(IsCurrentSelected));
                NotifyOfPropertyChange(nameof(ChkboxString));
            }
        }

        public string ChkboxString
        {
            get
            {
                if (_isCurrentSelected)
                {
                    return "Current";
                }
                else
                {
                    return "History";
                }
            }
        }

        private bool _btnTableIsEnabled = false;

        public bool BtnTableIsEnabled
        {
            get => _btnTableIsEnabled;
            set
            {
                _btnTableIsEnabled = value;
                NotifyOfPropertyChange(nameof(BtnTableIsEnabled));
            }
        }

        private TwoTableDataItem _selectedTwoTableData;

        public TwoTableDataItem SelectedTwoTableData
        {
            get => _selectedTwoTableData;
            set
            {
                _selectedTwoTableData = value;
                NotifyOfPropertyChange(nameof(SelectedTwoTableData));
            }
        }

        Dictionary<int, ObservableCollection<StepDataItem>> tableStepListA = new Dictionary<int, ObservableCollection<StepDataItem>>();
        Dictionary<int, ObservableCollection<StepDataItem>> tableStepListB = new Dictionary<int, ObservableCollection<StepDataItem>>();



        /// <summary>
        /// IsVisibilityEdit
        /// </summary>
        public bool IsVisibilityEdit
        {
            get { return _isVisibilityEdit; }
            set { _isVisibilityEdit = value;
                NotifyOfPropertyChange(nameof(IsVisibilityEdit)); }
        }
        private bool _isVisibilityEdit = true;

        public string TimeA
        {
            get { return _timeA; }
            set
            {
                _timeA = value;
                NotifyOfPropertyChange("TimeA");
            }
        }
        private string _timeA = string.Empty;

        public string TimeB
        {
            get { return _timeB; }
            set
            {
                _timeB = value;
                NotifyOfPropertyChange("TimeB");
            }
        }
        private string _timeB = string.Empty;


        public int SelectTableIndex { get; set; } = 1;


        public RecipesCompareTwoViewModel()
        {
            StepListA = new ObservableCollection<StepDataItem>();
            ParamListA = new ObservableCollection<ParamDataItem>();
            WholeListA = new ObservableCollection<LineDataItem>();

            StepListB = new ObservableCollection<StepDataItem>();
            ParamListB = new ObservableCollection<ParamDataItem>();
            WholeListB = new ObservableCollection<LineDataItem>();
        }

        public RecipesCompareTwoViewModel(ShowRecipeHistory showRecipeHistoryA, ShowRecipeHistory showRecipeHistoryB)
        {
            IsVisibilityEdit = false;
            StepListA = new ObservableCollection<StepDataItem>();
            ParamListA = new ObservableCollection<ParamDataItem>();
            WholeListA = new ObservableCollection<LineDataItem>();

            StepListB = new ObservableCollection<StepDataItem>();
            ParamListB = new ObservableCollection<ParamDataItem>();
            WholeListB = new ObservableCollection<LineDataItem>();

            if (showRecipeHistoryA != null && showRecipeHistoryB != null)
            {
                TimeA = showRecipeHistoryA.LastRevisionTime.ToString("yyyy-MM-dd HH:mm:ss");
                TimeB = showRecipeHistoryB.LastRevisionTime.ToString("yyyy-MM-dd HH:mm:ss");
                RecipeA = showRecipeHistoryA.Recipe_Path;
                RecipeB = showRecipeHistoryB.Recipe_Path;
                LoadData(showRecipeHistoryA.Recipe_Path, true, true, false);
                LoadData(showRecipeHistoryB.Recipe_Path, false, true, false);
                Recompare();
                GetStepList();
                SyncShowDiffSteps(IsShowDiffSteps);
            }
        }

        protected override void OnInitialize()
        {
            base.OnInitialize();

            var chamberType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedChamberType");
            if (chamberType == null)
            {
                ChamberType = new ObservableCollection<string>() { "Default" };
            }
            else
            {
                ChamberType = new ObservableCollection<string>(((string)(chamberType)).Split(','));
            }
            ChamberTypeIndexSelection = 0;

            //Etch:Process,Clean,Chuck,Dechuck;CVD:Process,Clean;
            //var processType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedProcessType");
            //if (processType == null)
            //{
            //    RecipeProcessType = new ObservableCollection<string>() { "Process" };
            //}
            //else
            //{
            //    RecipeProcessType = new ObservableCollection<string>(((string)processType).Split(','));
            //}
            RecipeProcessType = new ObservableCollection<string>();
            var processType = QueryDataClient.Instance.Service.GetConfig("System.CompareRecipeType");
            if (processType != null)
            {
                var sss = ((string)processType).Split(';');
                foreach (var item in sss)
                {
                    RecipeProcessType.Add(item);
                }
            }
            ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();

            UpdateProcessTypeFileList();
        }

        protected override void OnActivate()
        {
            base.OnActivate();
        }

        protected override void OnDeactivate(bool close)
        {
            base.OnDeactivate(close);
        }

        protected override void OnViewLoaded(object view)
        {
            base.OnViewLoaded(view);
            if (((RecipesCompareTwoView)view).CboRecipeType.Items.Count > 0)
            {
                ((RecipesCompareTwoView)view).CboRecipeType.SelectedIndex = 0;
            }
        }

        public void SelectChangedRecipeType(SelectionChangedEventArgs eventArgs)
        {
            string recipeType = null;
            recipeType = eventArgs.AddedItems[0].ToString();
            if (recipeType == "sub" || recipeType == "alarm" || recipeType == "abort" || recipeType == "idle" || recipeType == "reset")
            {
                BtnTableIsEnabled = true;
            }
            else
            {
                BtnTableIsEnabled = false;
            }
        }

        public void UpdateProcessTypeFileList()
        {
            ProcessTypeFileList.Clear();
            for (int i = 0; i < RecipeProcessType.Count; i++)
            {
                var type = new ProcessTypeFileItem();
                type.ProcessType = RecipeProcessType[i];
                var prefix = $"{ChamberType[ChamberTypeIndexSelection]}\\{RecipeProcessType[i]}";

                ProcessTypeFileList.Add(type);
            }

            while (ProcessTypeFileList.Count > RecipeProcessType.Count)
            {
                ProcessTypeFileList.RemoveAt(0);
            }
        }

        public void SelectA()
        {
            SelectRecipe(true);
        }

        public void SelectB()
        {
            SelectRecipe(false);
            //if (IsCurrentSelected)
            //{
            // SelectBCurrent();
            //}
            //else
            //{
            //    SelectBHistory();
            //}
        }

        public void SelectBHistory()
        {
            // SelectRecipe(false);
            try
            {
                RecipeCompareSelectDialogViewModel dialog = new RecipeCompareSelectDialogViewModel();
                dialog.DisplayName = "Select Recipe";
                SystemName = _module;
                dialog.IsSelectedA = false;
                var recipeProvider = new RecipeProvider();
                dialog.Chambers.Clear();
                recipeProvider.RestoreRecipeFolderList().ForEach(x => dialog.Chambers.Add(x));
                string[] recipeProcessType = null;
                if (string.IsNullOrEmpty(SelectedRecipeType))
                {
                    var processType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedProcessType");
                    if (processType == null)
                    {
                        processType = "Process";
                    }

                    var ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
                    recipeProcessType = ((string)processType).Split(',');
                }
                else
                {
                    recipeProcessType = new string[] { SelectedRecipeType };
                }
                string[] partsType1 = new string[] { };
                string[] partsType2 = new string[] { };

                for (int i = 0; i < recipeProcessType.Length; i++)
                {
                    var type = new ProcessTypeFileItem();
                    type.ProcessType = recipeProcessType[i];
                    var prefix = $"Furnace\\{recipeProcessType[i]}";
                    var recipes = recipeProvider.GetXmlRecipeList(prefix, false);

                    string[] parts = Regex.Split(recipes, "<");
                    if (i == 0)
                    {
                        partsType1 = parts;
                    }
                    else if (i == 1)
                    {
                        partsType2 = parts;
                    }


                    string recipeChamber;
                    recipeChamber = "<" + parts[1];
                    foreach (string part in parts)
                    {
                        if (part.Contains($".{SystemName}"))
                        {

                            string temp = part.Replace($".{SystemName}", string.Empty);
                            recipeChamber += "<" + temp;
                        }
                    }

                    if (parts.Length > 2)
                    {
                        recipeChamber += "<" + parts[parts.Length - 1];
                    }

                    type.FileListByProcessType = RecipeSequenceTreeBuilder.BuildFileNode(prefix, "", false, recipeChamber)[0].Files;
                    ProcessTypeFileList.Add(type);
                }

                dialog.ProcessTypeFileList = ProcessTypeFileList;

                WindowManager wm = new WindowManager();
                bool? bret = wm.ShowDialog(dialog);
                if (!(bool)bret)
                    return;

                _module = dialog.SelectedChamber;
                string suffix = $".{_module}";

                string dialogResult = dialog.DialogResult;
                bool isFullPath = false;
                if (dialogResult.Contains(".rcp"))
                    isFullPath = true;
                string recipeName = dialogResult;

                RecipeB = recipeName;
                NotifyOfPropertyChange(nameof(RecipeB));
                NotifyOfPropertyChange(nameof(EnableButtonRemoveB));
                if (string.IsNullOrEmpty(RecipeB))
                {
                    string[] recipe2 = RecipeB.Split('\\'); string r2 = recipe2[0];
                }
                LoadData(recipeName, false, false, isFullPath);

                Recompare();

                SyncShowDiffSteps(IsShowDiffSteps);
            }
            catch (Exception ex)
            {

                throw;
            }
        }

        public void SelectBCurrent()
        {
            try
            {
                RecipeCompareSelectDialogViewModel dialog = new RecipeCompareSelectDialogViewModel();
                dialog.DisplayName = "Select Recipe";
                SystemName = _module;

                var recipeProvider = new RecipeProvider();
                var processType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedProcessType");
                if (processType == null)
                {
                    processType = "Process";
                }

                var ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
                string[] recipeProcessType = ((string)processType).Split(',');

                string[] partsType1 = new string[] { };
                string[] partsType2 = new string[] { };

                for (int i = 0; i < recipeProcessType.Length; i++)
                {
                    var type = new ProcessTypeFileItem();
                    type.ProcessType = recipeProcessType[i];
                    var prefix = $"Furnace\\{recipeProcessType[i]}";
                    type.FileListByProcessType = RecipeSequenceTreeBuilder.GetFileNodeParameterList(prefix);
                    ProcessTypeFileList.Add(type);
                }

                dialog.ProcessTypeFileList = ProcessTypeFileList;

                WindowManager wm = new WindowManager();
                bool? bret = wm.ShowDialog(dialog);
                if (!(bool)bret)
                    return;

                _module = dialog.SelectedChamber;
                string suffix = $".{_module}";

                string dialogResult = dialog.DialogResult;
                bool isFullPath = false;
                if (dialogResult.Contains(".rcp"))
                    isFullPath = true;
                string recipeName = dialogResult;
                RecipeB = recipeName;
                NotifyOfPropertyChange(nameof(RecipeB));
                NotifyOfPropertyChange(nameof(EnableButtonRemoveB));
                if (!string.IsNullOrEmpty(RecipeA) && !string.IsNullOrEmpty(RecipeB))
                {
                    string[] recipe1 = RecipeA.Split('\\'); string r1 = recipe1[0];
                    string[] recipe2 = RecipeB.Split('\\'); string r2 = recipe2[0];
                    if (r1 != r2)
                    {
                        if (MessageBoxResult.Yes != MessageBox.Show($"腔体类型不一致! \n 是否继续比较 ?", "", MessageBoxButton.YesNo, MessageBoxImage.Information))
                        {
                            RemoveSelectB();
                            return;
                        }
                    }
                }
                LoadData(recipeName, false, true, isFullPath);
                Recompare();
                GetStepList();
                SyncShowDiffSteps(IsShowDiffSteps);
            }
            catch (Exception ex)
            {
                LOG.Error(ex.Message);
            }
        }

        private void SelectRecipe(bool isSelectA)
        {
            if (!BtnTableIsEnabled)
            {
                NoTableRecipe(isSelectA);
            }
            else
            {
                TableRecipe(isSelectA);
            }
        }

        private void NoTableRecipe(bool isSelectA)
        {
            try
            {
                RecipeCompareSelectDialogViewModel dialog = new RecipeCompareSelectDialogViewModel();
                dialog.DisplayName = "Select Recipe";
                SystemName = _module;

                var recipeProvider = new RecipeProvider();
                string[] recipeProcessType = null;
                var ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
                if (string.IsNullOrEmpty(SelectedRecipeType))
                {
                    var processType = QueryDataClient.Instance.Service.GetConfig("System.Recipe.SupportedProcessType");
                    if (processType == null)
                    {
                        processType = "Process";
                    }
                    recipeProcessType = ((string)processType).Split(',');
                }
                else
                {
                    recipeProcessType = new string[] { SelectedRecipeType };
                }
                string[] partsType1 = new string[] { };
                string[] partsType2 = new string[] { };

                for (int i = 0; i < recipeProcessType.Length; i++)
                {
                    var type = new ProcessTypeFileItem();
                    type.ProcessType = recipeProcessType[i];
                    var prefix = $"Furnace\\{recipeProcessType[i]}";
                    var recipes = recipeProvider.GetXmlRecipeList(prefix, false);
                    type.FileListByProcessType = RecipeSequenceTreeBuilder.GetFileNodeParameterList(prefix);
                    ProcessTypeFileList.Add(type);
                }

                dialog.ProcessTypeFileList = ProcessTypeFileList;

                WindowManager wm = new WindowManager();
                bool? bret = wm.ShowDialog(dialog);
                if (!(bool)bret)
                    return;

                _module = dialog.SelectedChamber;
                string suffix = $".{_module}";

                string dialogResult = dialog.DialogResult;
                bool isFullPath = false;
                if (dialogResult.Contains(".rcp"))
                    isFullPath = true;
                string recipeName = dialogResult;
                if (isSelectA)
                {
                    RecipeA = recipeName;
                    NotifyOfPropertyChange(nameof(RecipeA));
                    NotifyOfPropertyChange(nameof(EnableButtonRemoveA));
                }
                else
                {
                    RecipeB = recipeName;
                    NotifyOfPropertyChange(nameof(RecipeB));
                    NotifyOfPropertyChange(nameof(EnableButtonRemoveB));
                }
                if (!string.IsNullOrEmpty(RecipeA) && !string.IsNullOrEmpty(RecipeB))
                {
                    string[] recipe1 = RecipeA.Split('\\'); string r1 = recipe1[0];
                    string[] recipe2 = RecipeB.Split('\\'); string r2 = recipe2[0];
                    if (r1 != r2)
                    {
                        if (MessageBoxResult.Yes != MessageBox.Show($"腔体类型不一致! \n 是否继续比较 ?", "", MessageBoxButton.YesNo, MessageBoxImage.Information))
                        {
                            RemoveSelectB();
                            return;
                        }
                    }
                }
                LoadData(recipeName, isSelectA, true, isFullPath);

                Recompare();
                GetStepList();
                SyncShowDiffSteps(IsShowDiffSteps);
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        private void TableRecipe(bool isSelectA)
        {
            try
            {
                RecipeCompareSelectDialogViewModel dialog = new RecipeCompareSelectDialogViewModel();
                dialog.DisplayName = "Select Recipe";
                SystemName = _module;

                var recipeProvider = new RecipeProvider();
                string recipeProcessType = null;
                var ProcessTypeFileList = new ObservableCollection<ProcessTypeFileItem>();
                if (string.IsNullOrEmpty(SelectedRecipeType))
                {
                    //弹出告警消息
                    return;
                }
                else
                {
                    recipeProcessType = SelectedRecipeType;
                }
                string[] partsType1 = new string[] { };
                string[] partsType2 = new string[] { };
                var type = new ProcessTypeFileItem();
                type.ProcessType = recipeProcessType;
                var prefix = $"Furnace\\{recipeProcessType}";
                var recipes = recipeProvider.GetXmlRecipeList(prefix, false);
                type.FileListByProcessType = RecipeSequenceTreeBuilder.GetFileNodeParameterList(prefix);
                ProcessTypeFileList.Add(type);

                dialog.ProcessTypeFileList = ProcessTypeFileList;

                WindowManager wm = new WindowManager();
                bool? bret = wm.ShowDialog(dialog);
                if (!(bool)bret)
                    return;

                _module = dialog.SelectedChamber;
                string suffix = $".{_module}";

                string dialogResult = dialog.DialogResult;
                bool isFullPath = false;
                if (dialogResult.Contains(".rcp"))
                    isFullPath = true;
                string recipeName = dialogResult;
                if (isSelectA)
                {
                    RecipeA = recipeName;
                    NotifyOfPropertyChange(nameof(RecipeA));
                    NotifyOfPropertyChange(nameof(EnableButtonRemoveA));
                }
                else
                {
                    RecipeB = recipeName;
                    NotifyOfPropertyChange(nameof(RecipeB));
                    NotifyOfPropertyChange(nameof(EnableButtonRemoveB));
                }
                if (!string.IsNullOrEmpty(RecipeA) && !string.IsNullOrEmpty(RecipeB))
                {
                    string[] recipe1 = RecipeA.Split('\\'); string r1 = recipe1[0];
                    string[] recipe2 = RecipeB.Split('\\'); string r2 = recipe2[0];
                    if (r1 != r2)
                    {
                        if (MessageBoxResult.Yes != MessageBox.Show($"腔体类型不一致! \n 是否继续比较 ?", "", MessageBoxButton.YesNo, MessageBoxImage.Information))
                        {
                            RemoveSelectB();
                            return;
                        }
                    }
                }
                LoadTableData(recipeName, isSelectA, true, isFullPath);
                RecompareTableByName();
                GetTableStepList(isSelectA);
                SyncShowDiffSteps(IsShowDiffSteps);
            }
            catch (Exception ex)
            {
                throw;
            }
        }
        public void GetStepList()
        {
            StepList.Clear();
            if (StepListA == null || StepListA.Count == 0)
            {
                if (StepListB == null || StepListB.Count == 0)
                { return; }
                else
                {
                    foreach (var item in StepListB)
                    {
                        var tempStep = new TwoStepDataItem();
                        tempStep.BStepNumber = item.StepNumber;
                        tempStep.BStepName = item.StepName;
                        tempStep.IsDiff = item.IsDiff;
                        StepList.Add(tempStep);
                    }

                }
            }
            else
            {
                if (StepListB == null || StepListB.Count == 0)
                {
                    foreach (var item in StepListA)
                    {
                        var tempStep = new TwoStepDataItem();
                        tempStep.AStepNumber = item.StepNumber;
                        tempStep.AStepName = item.StepName;
                        tempStep.IsDiff = item.IsDiff;
                        StepList.Add(tempStep);
                    }
                }
                else
                {
                    int bIndex = 0;
                    int oldIndex = 0;
                    foreach (var item in StepListA)
                    {
                        var tempB = StepListB.FirstOrDefault(x => x.StepName == item.StepName);
                        if (tempB != null)
                        {
                            bIndex = StepListB.IndexOf(tempB);
                            if (bIndex != 0 && bIndex != oldIndex + 1)
                            {
                                for (int i = oldIndex + 1; i < bIndex; i++)
                                {
                                    var bStep = new TwoStepDataItem();
                                    bStep.AStepNumber = "";
                                    bStep.AStepName = "";
                                    bStep.BStepNumber = StepListB[i].StepNumber;
                                    bStep.BStepName = StepListB[i].StepName;
                                    bStep.IsDiff = false;
                                    StepList.Add(bStep);
                                }
                            }
                            if (oldIndex > bIndex)
                            {
                                var tempStepA = new TwoStepDataItem();
                                tempStepA.AStepNumber = item.StepNumber;
                                tempStepA.AStepName = item.StepName;
                                tempStepA.IsDiff = false;
                                StepList.Add(tempStepA);
                                continue;
                            }
                            else
                            {
                                oldIndex = bIndex;
                            }
                            var tempStep = new TwoStepDataItem();
                            tempStep.AStepNumber = item.StepNumber;
                            tempStep.AStepName = item.StepName;
                            tempStep.BStepNumber = tempB.StepNumber;
                            tempStep.BStepName = tempB.StepName;
                            tempStep.IsDiff = tempB.IsDiff;
                            StepList.Add(tempStep);
                        }
                        else
                        {
                            var tempStep = new TwoStepDataItem();
                            tempStep.AStepNumber = item.StepNumber;
                            tempStep.AStepName = item.StepName;
                            tempStep.IsDiff = item.IsDiff;
                            tempStep.BStepNumber = "";
                            tempStep.BStepName = "";
                            StepList.Add(tempStep);
                        }
                    }
                    if (bIndex + 1 < StepListB.Count)
                    {
                        for (int i = bIndex + 1; i < StepListB.Count; i++)
                        {
                            var bStep = new TwoStepDataItem();
                            bStep.AStepNumber = "";
                            bStep.AStepName = "";
                            bStep.BStepNumber = StepListB[i].StepNumber;
                            bStep.BStepName = StepListB[i].StepName;
                            bStep.IsDiff = StepListB[i].IsDiff;
                            StepList.Add(bStep);
                        }
                    }
                }

            }
        }

        public void GetTableStepList(bool isSelectA, int tableInex = 1)
        {
            StepList.Clear();
            TwoTableDataItem tempTable = new TwoTableDataItem();
            tempTable.Index = tableInex;
            var tableA = _mapTableStepParamA.Keys.FirstOrDefault(x => x.TableIndex == tableInex.ToString());
            if (tableA != null)
            {
                tempTable.ATableName = tableA.TableName;
            }
            var tableB = _mapTableStepParamB.Keys.FirstOrDefault(x => x.TableIndex == tableInex.ToString());
            if (tableB != null)
            {
                tempTable.BTableName = tableB.TableName;
            }
            if (isSelectA)
            {
                StepListA.Clear();

                if (tableStepListA.Keys.Contains(tableInex))
                {

                    (tableStepListA[tableInex].OrderBy(x => int.Parse(x.StepNumber))).ToList().ForEach(x => StepListA.Add(x));
                }
                NotifyOfPropertyChange(nameof(StepListA));
            }
            else
            {
                StepListB.Clear();
                if (tableStepListB.Keys.Contains(tableInex))
                {
                    (tableStepListB[tableInex].OrderBy(x => int.Parse(x.StepNumber))).ToList().ForEach(x => StepListB.Add(x));
                }
                NotifyOfPropertyChange(nameof(StepListB));
            }

            if (StepListA == null || StepListA.Count == 0)
            {
                if (StepListB == null || StepListB.Count == 0)
                { return; }
                else
                {
                    foreach (var item in StepListB)
                    {
                        var tempStep = new TwoStepDataItem();
                        tempStep.BStepNumber = item.StepNumber;
                        tempStep.BStepName = item.StepName;
                        tempStep.IsDiff = item.IsDiff;
                        StepList.Add(tempStep);
                    }

                }
            }
            else
            {
                if (StepListB == null || StepListB.Count == 0)
                {
                    foreach (var item in StepListA)
                    {
                        var tempStep = new TwoStepDataItem();
                        tempStep.AStepNumber = item.StepNumber;
                        tempStep.AStepName = item.StepName;
                        tempStep.IsDiff = item.IsDiff;
                        StepList.Add(tempStep);
                    }
                }
                else
                {
                    int bIndex = 0;
                    int oldIndex = 0;
                    foreach (var item in StepListA)
                    {
                        var tempB = StepListB.FirstOrDefault(x => x.StepName == item.StepName);
                        if (tempB != null)
                        {
                            bIndex = StepListB.IndexOf(tempB);
                            if (bIndex != 0 && bIndex != oldIndex + 1)
                            {
                                for (int i = oldIndex + 1; i < bIndex; i++)
                                {
                                    var bStep = new TwoStepDataItem();
                                    bStep.AStepNumber = "";
                                    bStep.AStepName = "";
                                    bStep.BStepNumber = StepListB[i].StepNumber;
                                    bStep.BStepName = StepListB[i].StepName;
                                    bStep.IsDiff = false;
                                    StepList.Add(bStep);
                                }
                            }
                            if (oldIndex > bIndex)
                            {
                                var tempStepA = new TwoStepDataItem();
                                tempStepA.AStepNumber = item.StepNumber;
                                tempStepA.AStepName = item.StepName;
                                tempStepA.IsDiff = false;
                                StepList.Add(tempStepA);
                                continue;
                            }
                            else
                            {
                                oldIndex = bIndex;
                            }
                            var tempStep = new TwoStepDataItem();
                            tempStep.AStepNumber = item.StepNumber;
                            tempStep.AStepName = item.StepName;
                            tempStep.BStepNumber = tempB.StepNumber;
                            tempStep.BStepName = tempB.StepName;
                            tempStep.IsDiff = tempB.IsDiff;
                            StepList.Add(tempStep);
                        }
                        else
                        {
                            var tempStep = new TwoStepDataItem();
                            tempStep.AStepNumber = item.StepNumber;
                            tempStep.AStepName = item.StepName;
                            tempStep.IsDiff = item.IsDiff;
                            tempStep.BStepNumber = "";
                            tempStep.BStepName = "";
                            StepList.Add(tempStep);
                        }
                    }
                    if (bIndex + 1 < StepListB.Count)
                    {
                        for (int i = bIndex + 1; i < StepListB.Count; i++)
                        {
                            var bStep = new TwoStepDataItem();
                            bStep.AStepNumber = "";
                            bStep.AStepName = "";
                            bStep.BStepNumber = StepListB[i].StepNumber;
                            bStep.BStepName = StepListB[i].StepName;
                            bStep.IsDiff = StepListB[i].IsDiff;
                            StepList.Add(bStep);
                        }
                    }
                }

            }


            SelectedTwoTableData = tempTable;
        }


        public void LoadData(string selectedRecipePath, bool isSelectA, bool isCurrent, bool isFullPath)
        {
            var array = selectedRecipePath.Split(new char[] { '\\' });

            string recipeName = array[array.Length - 1];

            XmlDocument doc = isSelectA ? _domA : _domB;

            string prefixPath = (isSelectA ? RecipeA : RecipeB).Replace(recipeName, "");

            var _recipeProvider = new RecipeProvider();
            string recipeContent;
            if (isSelectA)
            {
                recipeContent = isFullPath ? _recipeProvider.LoadRecipeByFullPath(selectedRecipePath) : _recipeProvider.LoadRecipe(prefixPath, recipeName, false);
            }
            else
            {
                if (isCurrent)
                {
                    recipeContent = _recipeProvider.LoadRecipe(prefixPath, recipeName);
                }
                else
                {
                    recipeContent = _recipeProvider.LoadRestoreRecipe(prefixPath, recipeName);
                }
            }

            if (string.IsNullOrEmpty(recipeContent))
            {
                MessageBox.Show($"{prefixPath}\\{recipeName} is empty, please confirm the file is valid.");
                return;
            }

            if (isSelectA)
            {
                BackInnerXmlTextA.Clear();

                if (BackInnerXmlTextB.Count > 0)
                {
                    string dataXml = BackInnerXmlTextB[0];
                    BackInnerXmlTextB.Clear();
                    BackInnerXmlTextB.Add(dataXml);
                }

            }
            else
            {
                BackInnerXmlTextB.Clear();

                if (BackInnerXmlTextA.Count > 0)
                {
                    string dataXml = BackInnerXmlTextA[0];
                    BackInnerXmlTextA.Clear();
                    BackInnerXmlTextA.Add(dataXml);
                }
            }
            if (isSelectA)
            {
                _pathPrefixA = prefixPath;
                _mapLineTextA = new Dictionary<string, LineDataItem>();
                BackInnerXmlTextA.Add(recipeContent);
            }
            else
            {
                _pathPrefixB = prefixPath;
                _mapLineTextB = new Dictionary<string, LineDataItem>();
                BackInnerXmlTextB.Add(recipeContent);
            }
            LoadrecipeContentData(recipeContent, isSelectA);
        }


        public void LoadTableData(string selectedRecipePath, bool isSelectA, bool isCurrent, bool isFullPath)
        {
            var array = selectedRecipePath.Split(new char[] { '\\' });

            string recipeName = array[array.Length - 1];

            XmlDocument doc = isSelectA ? _domA : _domB;

            string prefixPath = (isSelectA ? RecipeA : RecipeB).Replace(recipeName, "");

            var _recipeProvider = new RecipeProvider();
            string recipeContent;
            if (isSelectA)
            {
                recipeContent = isFullPath ? _recipeProvider.LoadRecipeByFullPath(selectedRecipePath) : _recipeProvider.LoadRecipe(prefixPath, recipeName, false);
            }
            else
            {
                if (isCurrent)
                {
                    recipeContent = _recipeProvider.LoadRecipe(prefixPath, recipeName);
                }
                else
                {
                    recipeContent = _recipeProvider.LoadRestoreRecipe(prefixPath, recipeName);
                }
            }
            if (string.IsNullOrEmpty(recipeContent))
            {
                MessageBox.Show($"{prefixPath}\\{recipeName} is empty, please confirm the file is valid.");
                return;
            }
            if (isSelectA)
            {
                _pathPrefixA = prefixPath;
            }
            else
            {
                _pathPrefixB = prefixPath;
            }
            LoadTableRecipeContentData(recipeContent, isSelectA);
        }


        public void StepGridSelectionChangedA()
        {
            //if (StepSelectionA == null)
            //{
            //    ParamListA.Clear();
            //    NotifyOfPropertyChange(nameof(ParamListA));
            //    return;
            //}

            //if (_mapStepParamA.ContainsKey(StepSelectionA.StepNumber))
            //{
            //    ParamListA = _mapStepParamA[StepSelectionA.StepNumber];
            //    foreach (ParamDataItem item in ParamListA)
            //    {
            //        item.IsHidden = (!item.IsDiff && !item.IsExtra && IsShowDiffParams) ? true : false;
            //    }
            //    NotifyOfPropertyChange(nameof(ParamListA));
            //    NotifyOfPropertyChange(nameof(StepSelectionA));
            //    StepSelectionA.InvokePropertyChanged();
            //}
        }


        private void LoadrecipeContentData(string recipeContent, bool isSelectA)
        {
            XmlDocument doc = isSelectA ? _domA : _domB;

            if (isSelectA)
            {
                _mapLineTextA = new Dictionary<string, LineDataItem>();
                //BackInnerXmlTextA.Add(recipeContent);
            }
            else
            {
                _mapLineTextB = new Dictionary<string, LineDataItem>();
                //BackInnerXmlTextB.Add(recipeContent);
            }

            string[] allText = recipeContent.Split(new string[] { "\r\n" }, StringSplitOptions.None);
            int number = 0;
            ObservableCollection<LineDataItem> lineData = new ObservableCollection<LineDataItem>();
            foreach (string lineText in allText)
            {
                LineDataItem line = new LineDataItem();
                line.LineNumber = (++number).ToString();
                line.LineText = lineText;
                if (!string.IsNullOrEmpty(lineText))
                {
                    lineData.Add(line);
                    if (isSelectA)
                    {
                        _mapLineTextA[line.LineNumber] = line;
                    }
                    else
                    {
                        _mapLineTextB[line.LineNumber] = line;
                    }
                }
            }

            doc.LoadXml(recipeContent);

            ObservableCollection<StepDataItem> stepData = new ObservableCollection<StepDataItem>();

            XmlNodeList nodeSteps = doc.SelectNodes($"Aitex/TableRecipeData/Module[@Name='PM1']/Step");
            if (nodeSteps == null)
                nodeSteps = doc.SelectNodes($"Aitex/TableRecipeData/Step");


            foreach (XmlNode nodeStep in nodeSteps)
            {
                ObservableCollection<ParamDataItem> paramData = new ObservableCollection<ParamDataItem>();
                StepDataItem step = new StepDataItem();

                foreach (XmlAttribute attr in nodeStep.Attributes)
                {
                    if (attr.Name == "StepNo")
                        step.StepNumber = attr.Value;
                    else if (attr.Name == "Name")
                        step.StepName = attr.Value;
                    else
                    {
                        if (!attr.Name.Contains("IsSaved"))
                        {
                            ParamDataItem param = new ParamDataItem();
                            param.ParamName = attr.Name;
                            param.ParamValue = attr.Value;
                            paramData.Add(param);
                        }
                    }
                }
                stepData.Add(step);

                if (isSelectA)
                {
                    _mapStepParamA[step.StepNumber] = paramData;
                }
                else
                {
                    _mapStepParamB[step.StepNumber] = paramData;
                }
            }

            if (isSelectA)
            {
                StepListA = new ObservableCollection<StepDataItem>(stepData.OrderBy(x => int.Parse(x.StepNumber)));
                NotifyOfPropertyChange(nameof(StepListA));
                WholeListA = new ObservableCollection<LineDataItem>(lineData.OrderBy(x => int.Parse(x.LineNumber)));
                NotifyOfPropertyChange(nameof(WholeListA));
            }
            else
            {
                StepListB = new ObservableCollection<StepDataItem>(stepData.OrderBy(x => int.Parse(x.StepNumber)));
                NotifyOfPropertyChange(nameof(StepListB));
                WholeListB = new ObservableCollection<LineDataItem>(lineData.OrderBy(x => int.Parse(x.LineNumber)));
                NotifyOfPropertyChange(nameof(WholeListB));
            }
        }


        private void LoadTableRecipeContentData(string recipeContent, bool isSelectA)
        {
            XmlDocument doc = isSelectA ? _domA : _domB;

            string[] allText = recipeContent.Split(new string[] { "\r\n" }, StringSplitOptions.None);
            int number = 0;
            doc.LoadXml(recipeContent);

            XmlNodeList nodeTables = doc.SelectNodes($"Aitex/TableRecipeData/Tables/Table");
            if (isSelectA)
            {
                tableStepListA.Clear();
                _mapTableStepParamA.Clear();
            }
            else
            {
                tableStepListB.Clear();
                _mapTableStepParamB.Clear();
            }
            foreach (XmlNode nodeTable in nodeTables)
            {
                TableDataItem tableDataItem = new TableDataItem();
                foreach (XmlAttribute attrTable in nodeTable.Attributes)
                {
                    switch (attrTable.Name)
                    {
                        case "Index":
                            tableDataItem.TableIndex = attrTable.Value;
                            break;
                        case "Name":
                            tableDataItem.TableName = attrTable.Value;
                            break;
                        case "EndStatus":
                            tableDataItem.EndStatus = attrTable.Value;
                            break;
                        default:
                            break;
                    }
                }
                XmlNodeList nodeSteps = nodeTable.SelectNodes("Step");
                ObservableCollection<StepDataItem> stepData = new ObservableCollection<StepDataItem>();
                Dictionary<string, ObservableCollection<ParamDataItem>> _tempMapStepParamA = new Dictionary<string, ObservableCollection<ParamDataItem>>();
                Dictionary<string, ObservableCollection<ParamDataItem>> _tempMapStepParamB = new Dictionary<string, ObservableCollection<ParamDataItem>>();
                foreach (XmlNode nodeStep in nodeSteps)
                {
                    ObservableCollection<ParamDataItem> paramData = new ObservableCollection<ParamDataItem>();
                    StepDataItem step = new StepDataItem();

                    foreach (XmlAttribute attr in nodeStep.Attributes)
                    {
                        if (attr.Name == "StepNo")
                            step.StepNumber = attr.Value;
                        else if (attr.Name == "Name")
                            step.StepName = attr.Value;
                        else
                        {
                            if (!attr.Name.Contains("IsSaved"))
                            {
                                ParamDataItem param = new ParamDataItem();
                                param.ParamName = attr.Name;
                                param.ParamValue = attr.Value;
                                paramData.Add(param);
                            }
                        }
                    }
                    stepData.Add(step);
                    if (isSelectA)
                    {
                        _mapStepParamA[step.StepNumber] = paramData;
                        _tempMapStepParamA[step.StepNumber] = paramData;
                    }
                    else
                    {
                        _mapStepParamB[step.StepNumber] = paramData;
                        _tempMapStepParamB[step.StepNumber] = paramData;
                    }
                }

                if (isSelectA)
                {
                    var tableTemp = _mapTableStepParamA.Keys.FirstOrDefault(x => x.TableIndex == tableDataItem.TableIndex);
                    if (tableTemp != null)
                    {
                        _mapTableStepParamA[tableTemp] = _tempMapStepParamA;
                    }
                    else
                    {
                        _mapTableStepParamA.Add(tableDataItem, _tempMapStepParamA);
                    }
                    int tbIndex = 1;
                    int.TryParse(tableDataItem.TableIndex, out tbIndex);
                    if (tableStepListA.Keys.Contains(tbIndex))
                    {
                        tableStepListA[tbIndex] = stepData;
                    }
                    else
                    {
                        tableStepListA.Add(tbIndex, stepData);
                    }
                }
                else
                {
                    var tableTemp = _mapTableStepParamB.Keys.FirstOrDefault(x => x.TableIndex == tableDataItem.TableIndex);
                    if (tableTemp != null)
                    {
                        _mapTableStepParamB[tableTemp] = _tempMapStepParamB;
                    }
                    else
                    {
                        _mapTableStepParamB.Add(tableDataItem, _tempMapStepParamB);
                    }
                    int tbIndex = 1;
                    int.TryParse(tableDataItem.TableIndex, out tbIndex);
                    if (tableStepListB.Keys.Contains(tbIndex))
                    {
                        tableStepListB[tbIndex] = stepData;
                    }
                    else
                    {
                        tableStepListB.Add(tbIndex, stepData);
                    }
                }
            }

        }

        public void ParamGridSelectionChangedB()
        {
            if (ParamSelectionB == null)
            {
                return;
            }

            NotifyOfPropertyChange(nameof(ParamSelectionB));
            ParamSelectionB.InvokePropertyChanged();
        }

        public void WholeGridSelectionChangedA()
        {
            if (LineSelectionA == null)
            {
                return;
            }

            NotifyOfPropertyChange(nameof(LineSelectionA));
            LineSelectionA.InvokePropertyChanged();
        }

        public void WholeGridSelectionChangedB()
        {
            if (LineSelectionB == null)
            {
                return;
            }

            NotifyOfPropertyChange(nameof(LineSelectionB));
            LineSelectionB.InvokePropertyChanged();
        }

        public void SaveLineA()
        {
            if (LineSelectionA == null)
                return;
            foreach (LineDataItem lineDataItem in WholeListA)
            {
                if (lineDataItem.LineNumber == LineSelectionA.LineNumber)
                {
                    lineDataItem.LineText = LineSelectionA.LineText;
                    break;
                }
            }
            string recipeContent = "";
            for (int i = 0; i < WholeListA.Count; i++)
            {
                recipeContent += WholeListA[i].LineText + ((i == WholeListB.Count - 1) ? "" : "\r\n");
            }
            CopyToInnerXml(recipeContent, true);
            LoadrecipeContentData(recipeContent, true);
            Recompare();
            SyncShowDiffSteps(IsShowDiffSteps);
        }
        public void SaveLineB()
        {
            if (LineSelectionB == null)
                return;
            foreach (LineDataItem lineDataItem in WholeListB)
            {
                if (lineDataItem.LineNumber == LineSelectionB.LineNumber)
                {
                    lineDataItem.LineText = LineSelectionB.LineText;
                    break;
                }
            }
            string recipeContent = "";

            for (int i = 0; i < WholeListB.Count; i++)
            {
                recipeContent += WholeListB[i].LineText + ((i == WholeListB.Count - 1) ? "" : "\r\n");
            }


            CopyToInnerXml(recipeContent, false);
            LoadrecipeContentData(recipeContent, false);
            Recompare();
            SyncShowDiffSteps(IsShowDiffSteps);
        }

        private void Recompare()
        {
            if (IsCompareBySName)
            {
                RecompareStepByName();
            }
            RecompareWhole();
        }

        private void RecompareStepByStep()
        {
            if (StepListA == null || StepListB == null)
                return;
            var stepAMaxNumber = (StepListA == null || StepListA.Count() == 0) ? 0 : StepListA.Select(stepItem => int.Parse(stepItem.StepNumber)).Max();
            var stepBMaxNumber = (StepListB == null || StepListB.Count() == 0) ? 0 : StepListB.Select(stepItem => int.Parse(stepItem.StepNumber)).Max();
            int stepMaxNumber = stepAMaxNumber > stepBMaxNumber ? stepAMaxNumber : stepBMaxNumber;

            for (int i = 0; i < stepMaxNumber + 1; i++)
            {
                StepDataItem getStepA = (StepListA == null || StepListA.Count() == 0) ? null : (StepListA.Where(x => x.StepNumber == i.ToString()) == null ? null : StepListA.Where(x => x.StepNumber == i.ToString()).FirstOrDefault());
                StepDataItem getStepB = (StepListB == null || StepListB.Count() == 0) ? null : (StepListB.Where(x => x.StepNumber == i.ToString()) == null ? null : StepListB.Where(x => x.StepNumber == i.ToString()).FirstOrDefault());
                if (getStepA != null && getStepB != null)
                {
                    if (getStepA.StepName == getStepB.StepName)
                        getStepA.IsDiffName = getStepB.IsDiffName = false;
                    else
                        getStepA.IsDiffName = getStepB.IsDiffName = true;

                    ObservableCollection<ParamDataItem> paramA = _mapStepParamA.ContainsKey(i.ToString()) ? _mapStepParamA[i.ToString()] : null;
                    ObservableCollection<ParamDataItem> paramB = _mapStepParamB.ContainsKey(i.ToString()) ? _mapStepParamB[i.ToString()] : null;
                    bool isDiff = false;
                    bool IsExtra = true;
                    if (paramA != null && paramB == null)
                    {
                        foreach (var pa in paramA)
                        {
                            pa.IsExtra = true;
                            pa.IsDiff = false;
                        }
                    }
                    else if (paramA == null && paramB != null)
                    {
                        foreach (var pb in paramB)
                        {
                            pb.IsExtra = true;
                            pb.IsDiff = false;
                        }
                    }
                    else if (paramA != null && paramB != null)
                    {
                        foreach (var pa in paramA)
                        {
                            var getParam = paramB.Where(pb => pb.ParamName == pa.ParamName).FirstOrDefault();
                            if (getParam != null)
                            {
                                pa.IsExtra = false;
                                getParam.IsExtra = false;
                                getParam.IsDiff = pa.IsDiff = (pa.ParamValue != getParam.ParamValue);
                                if (pa.ParamValue != getParam.ParamValue)
                                {
                                    isDiff = true;
                                }
                            }
                        }
                        getStepA.IsExtra = getStepB.IsExtra = false;
                    }
                    if (paramA != null)
                    {
                        foreach (var pa in paramA)
                        {
                            pa.InvokePropertyChanged();
                        }
                    }
                    if (paramB != null)
                    {
                        foreach (var pb in paramB)
                        {
                            pb.InvokePropertyChanged();
                        }
                    }
                    getStepA.IsDiff = getStepB.IsDiff = isDiff;
                    getStepA.IsHidden = getStepB.IsHidden = !isDiff && IsShowDiffSteps ? true : false;
                    getStepA.InvokePropertyChanged();
                    getStepB.InvokePropertyChanged();
                }
                else if (getStepA == null && getStepB != null)
                {
                    getStepB.IsExtra = true;
                    getStepB.IsDiff = false;
                    ObservableCollection<ParamDataItem> paramB = _mapStepParamB.ContainsKey(getStepB.StepNumber) ? _mapStepParamB[getStepB.StepNumber] : null;
                    foreach (var pb in paramB)
                    {
                        pb.IsExtra = false;
                        pb.IsDiff = false;
                        pb.InvokePropertyChanged();
                    }
                    getStepB.InvokePropertyChanged();
                    continue;
                }
                else if (getStepA != null && getStepB == null)
                {
                    getStepA.IsExtra = true;
                    getStepA.IsDiff = false;
                    ObservableCollection<ParamDataItem> paramA = _mapStepParamA.ContainsKey(getStepA.StepNumber) ? _mapStepParamA[getStepA.StepNumber] : null;
                    foreach (var pa in paramA)
                    {
                        pa.IsExtra = false;
                        pa.IsDiff = false;
                        pa.InvokePropertyChanged();
                    }
                    getStepA.InvokePropertyChanged();
                    continue;
                }
                else
                {
                    continue;
                }
            }
            NotifyOfPropertyChange(nameof(StepListA));
            NotifyOfPropertyChange(nameof(StepListB));
        }


        private void RecompareStepByName()
        {
            if (StepListA == null || StepListB == null)
                return;
            var stepAMaxNumber = (StepListA == null || StepListA.Count() == 0) ? 0 : StepListA.Select(stepItem => int.Parse(stepItem.StepNumber)).Max();
            var stepBMaxNumber = (StepListB == null || StepListB.Count() == 0) ? 0 : StepListB.Select(stepItem => int.Parse(stepItem.StepNumber)).Max();
            int stepMaxNumber = stepAMaxNumber > stepBMaxNumber ? stepAMaxNumber : stepBMaxNumber;
            foreach (var getStepA in StepListA)
            {
                StepDataItem getStepB = (StepListB.Where(x => x.StepName == getStepA.StepName) == null ? null : StepListB.Where(x => x.StepName == getStepA.StepName).FirstOrDefault());
                if (getStepB == null)
                {
                    getStepA.IsDiff = false;
                    getStepA.IsExtra = true;
                    continue;
                }
                getStepA.IsDiffName = getStepB.IsDiffName = true;

                ObservableCollection<ParamDataItem> paramA = _mapStepParamA.ContainsKey(getStepA.StepNumber) ? _mapStepParamA[getStepA.StepNumber] : null;
                ObservableCollection<ParamDataItem> paramB = _mapStepParamB.ContainsKey(getStepB.StepNumber) ? _mapStepParamB[getStepB.StepNumber] : null;
                bool isDiff = false;
                bool IsExtra = true;
                if (paramA != null && paramB == null)
                {
                    foreach (var pa in paramA)
                    {
                        pa.IsExtra = true;
                        pa.IsDiff = false;
                    }
                }
                else if (paramA == null && paramB != null)
                {
                    foreach (var pb in paramB)
                    {
                        pb.IsExtra = true;
                        pb.IsDiff = false;
                    }
                }
                else if (paramA != null && paramB != null)
                {
                    foreach (var pa in paramA)
                    {
                        var getParam = paramB.Where(pb => pb.ParamName == pa.ParamName).FirstOrDefault();
                        if (getParam != null)
                        {
                            pa.IsExtra = false;
                            getParam.IsExtra = false;
                            getParam.IsDiff = pa.IsDiff = (pa.ParamValue != getParam.ParamValue);
                            if (pa.ParamValue != getParam.ParamValue)
                            {
                                isDiff = true;
                            }
                        }
                    }
                    getStepA.IsExtra = getStepB.IsExtra = false;
                }
                if (paramA != null)
                {
                    foreach (var pa in paramA)
                    {
                        pa.InvokePropertyChanged();
                    }
                }
                if (paramB != null)
                {
                    foreach (var pb in paramB)
                    {
                        pb.InvokePropertyChanged();
                    }
                }
                getStepA.IsDiff = getStepB.IsDiff = isDiff;
                getStepA.IsHidden = getStepB.IsHidden = !isDiff && IsShowDiffSteps ? true : false;
                getStepA.InvokePropertyChanged();
                getStepB.InvokePropertyChanged();
            }
            foreach (var getStepB in StepListB)
            {
                StepDataItem getStepA = (StepListA.Where(x => x.StepName == getStepB.StepName) == null ? null : StepListA.Where(x => x.StepName == getStepB.StepName).FirstOrDefault());
                if (getStepA == null)
                {
                    getStepB.IsDiff = false;
                    getStepB.IsExtra = true;
                    continue;
                }
                ObservableCollection<ParamDataItem> paramA = _mapStepParamA.ContainsKey(getStepA.StepNumber) ? _mapStepParamA[getStepA.StepNumber] : null;
                ObservableCollection<ParamDataItem> paramB = _mapStepParamB.ContainsKey(getStepB.StepNumber) ? _mapStepParamB[getStepB.StepNumber] : null;
                bool isDiff = false;
                foreach (var pb in paramB)
                {
                    var getParam = paramA.Where(p => p.ParamName == pb.ParamName).FirstOrDefault();
                    if (getParam != null)
                    {
                        pb.IsExtra = false;
                        getParam.IsExtra = false;
                        getParam.IsDiff = pb.IsDiff = (pb.ParamValue != getParam.ParamValue);
                        if (pb.ParamValue != getParam.ParamValue)
                        {
                            isDiff = true;
                        }
                        getParam.IsDiff = pb.IsDiff = (pb.ParamValue != getParam.ParamValue);
                    }
                    pb.InvokePropertyChanged();
                }
                getStepB.IsExtra = false;
                getStepB.IsDiff = isDiff;
                getStepB.InvokePropertyChanged();
            }

            NotifyOfPropertyChange(nameof(StepListA));
            NotifyOfPropertyChange(nameof(StepListB));
        }

        private void RecompareTableByName()
        {
            for (int i = 1; i < 21; i++)
            {
                ObservableCollection<StepDataItem> _stepListA = null;
                ObservableCollection<StepDataItem> _stepListB = null;
                if (tableStepListA.Keys.Contains(i))
                {
                    _stepListA = tableStepListA[i];
                }
                if (tableStepListB.Keys.Contains(i))
                {
                    _stepListB = tableStepListB[i];
                }
                if (_stepListA == null || _stepListB == null)
                    return;
                var stepAMaxNumber = (_stepListA == null || _stepListA.Count() == 0) ? 0 : _stepListA.Select(stepItem => int.Parse(stepItem.StepNumber)).Max();
                var stepBMaxNumber = (_stepListB == null || _stepListB.Count() == 0) ? 0 : _stepListB.Select(stepItem => int.Parse(stepItem.StepNumber)).Max();
                int stepMaxNumber = stepAMaxNumber > stepBMaxNumber ? stepAMaxNumber : stepBMaxNumber;
                foreach (var getStepA in _stepListA)
                {
                    StepDataItem getStepB = (_stepListB.Where(x => x.StepName == getStepA.StepName) == null ? null : _stepListB.Where(x => x.StepName == getStepA.StepName).FirstOrDefault());
                    if (getStepB == null)
                    {
                        getStepA.IsDiff = false;
                        getStepA.IsExtra = true;
                        continue;
                    }
                    getStepA.IsDiffName = getStepB.IsDiffName = true;
                    var tempA = _mapTableStepParamA.Keys.FirstOrDefault(x => x.TableIndex == i.ToString());
                    ObservableCollection<ParamDataItem> paramA = tempA != null && _mapTableStepParamA[tempA].ContainsKey(getStepA.StepNumber) ? _mapTableStepParamA[tempA][getStepA.StepNumber] : null;
                    var tempB = _mapTableStepParamB.Keys.FirstOrDefault(x => x.TableIndex == i.ToString());
                    ObservableCollection<ParamDataItem> paramB = tempB != null && _mapTableStepParamB[tempB].ContainsKey(getStepB.StepNumber) ? _mapTableStepParamB[tempB][getStepB.StepNumber] : null;
                    bool isDiff = false;
                    bool IsExtra = true;
                    if (paramA != null && paramB == null)
                    {
                        foreach (var pa in paramA)
                        {
                            pa.IsExtra = true;
                            pa.IsDiff = false;
                        }
                    }
                    else if (paramA == null && paramB != null)
                    {
                        foreach (var pb in paramB)
                        {
                            pb.IsExtra = true;
                            pb.IsDiff = false;
                        }
                    }
                    else if (paramA != null && paramB != null)
                    {
                        foreach (var pa in paramA)
                        {
                            var getParam = paramB.Where(pb => pb.ParamName == pa.ParamName).FirstOrDefault();
                            if (getParam != null)
                            {
                                pa.IsExtra = false;
                                getParam.IsExtra = false;
                                getParam.IsDiff = pa.IsDiff = (pa.ParamValue != getParam.ParamValue);
                                if (pa.ParamValue != getParam.ParamValue)
                                {
                                    isDiff = true;
                                }
                            }
                        }
                        getStepA.IsExtra = getStepB.IsExtra = false;
                    }
                    if (paramA != null)
                    {
                        foreach (var pa in paramA)
                        {
                            pa.InvokePropertyChanged();
                        }
                    }
                    if (paramB != null)
                    {
                        foreach (var pb in paramB)
                        {
                            pb.InvokePropertyChanged();
                        }
                    }
                    getStepA.IsDiff = getStepB.IsDiff = isDiff;
                    getStepA.IsHidden = getStepB.IsHidden = !isDiff && IsShowDiffSteps ? true : false;
                    //getStepA.InvokePropertyChanged();
                    //getStepB.InvokePropertyChanged();
                }
                foreach (var getStepB in _stepListB)
                {
                    StepDataItem getStepA = (_stepListA.Where(x => x.StepName == getStepB.StepName) == null ? null : _stepListA.Where(x => x.StepName == getStepB.StepName).FirstOrDefault());
                    if (getStepA == null)
                    {
                        getStepB.IsDiff = false;
                        getStepB.IsExtra = true;
                        continue;
                    }
                    var tempA = _mapTableStepParamA.Keys.FirstOrDefault(x => x.TableIndex == i.ToString());
                    ObservableCollection<ParamDataItem> paramA = tempA != null && _mapTableStepParamA[tempA].ContainsKey(getStepA.StepNumber) ? _mapTableStepParamA[tempA][getStepA.StepNumber] : null;
                    var tempB = _mapTableStepParamB.Keys.FirstOrDefault(x => x.TableIndex == i.ToString());
                    ObservableCollection<ParamDataItem> paramB = tempB != null && _mapTableStepParamB[tempB].ContainsKey(getStepB.StepNumber) ? _mapTableStepParamB[tempB][getStepB.StepNumber] : null;
                    bool isDiff = false;
                    foreach (var pb in paramB)
                    {
                        var getParam = paramA.Where(p => p.ParamName == pb.ParamName).FirstOrDefault();
                        if (getParam != null)
                        {
                            pb.IsExtra = false;
                            getParam.IsExtra = false;
                            getParam.IsDiff = pb.IsDiff = (pb.ParamValue != getParam.ParamValue);
                            if (pb.ParamValue != getParam.ParamValue)
                            {
                                isDiff = true;
                            }
                            getParam.IsDiff = pb.IsDiff = (pb.ParamValue != getParam.ParamValue);
                        }
                        pb.InvokePropertyChanged();
                    }
                    getStepB.IsExtra = false;
                    getStepB.IsDiff = isDiff;
                    getStepB.InvokePropertyChanged();
                }
                var tempParA = _mapTableStepParamA.Keys.FirstOrDefault(x => x.TableIndex == i.ToString());
                var tempParB = _mapTableStepParamB.Keys.FirstOrDefault(x => x.TableIndex == i.ToString());
                if (tempParA != null) tempParA.IsDiff = _stepListA?.Where(x => x.IsDiff).Count() == 0 ? false : true;
                if (tempParB != null) tempParB.IsDiff = _stepListB?.Where(x => x.IsDiff).Count() == 0 ? false : true;
            }


            NotifyOfPropertyChange(nameof(StepListA));
            NotifyOfPropertyChange(nameof(StepListB));
        }

        //private void RecompareStep()
        //{
        //    if (StepListA == null || StepListB == null)
        //        return;

        //    int i = 0;
        //    for (i = 0; i < StepListA.Count && i < StepListB.Count; i++)
        //    {
        //        if (StepListA[i].StepName == StepListB[i].StepName)
        //            StepListA[i].IsDiffName = StepListB[i].IsDiffName = false;
        //        else
        //            StepListA[i].IsDiffName = StepListB[i].IsDiffName = true;

        //        ObservableCollection<ParamDataItem> paramA = _mapStepParamA[StepListA[i].StepNumber];
        //        ObservableCollection<ParamDataItem> paramB = _mapStepParamB[StepListB[i].StepNumber];
        //        bool isDiff = false;
        //        bool IsExtra = true;
        //        foreach (var pa in paramA)
        //        {
        //            pa.IsExtra = true;

        //        }
        //        foreach (var pb in paramB)
        //        {
        //            pb.IsExtra = true;
        //        }
        //        foreach (var pa in paramA)
        //        {
        //            foreach (var pb in paramB)
        //            {
        //                if (pb.ParamName == pa.ParamName)
        //                {
        //                    pb.IsExtra = false;
        //                    pa.IsExtra = false;
        //                    pb.IsDiff = pa.IsDiff = (pa.ParamValue != pb.ParamValue);
        //                    if (pa.IsDiff)
        //                        isDiff = true;
        //                    break;
        //                }
        //            }
        //        }

        //        foreach (var pa in paramA)
        //        {
        //            pa.InvokePropertyChanged();
        //        }

        //        foreach (var pb in paramB)
        //        {
        //            pb.InvokePropertyChanged();
        //        }

        //        StepListA[i].IsDiff = StepListB[i].IsDiff = isDiff;
        //        StepListA[i].IsExtra = StepListB[i].IsExtra = false;

        //        StepListA[i].IsHidden = StepListB[i].IsHidden = !isDiff && IsShowDiffSteps ? true : false;

        //        StepListA[i].InvokePropertyChanged();
        //        StepListB[i].InvokePropertyChanged();
        //    }

        //    for (int j = i; j < StepListA.Count; j++)
        //    {
        //        StepListA[j].IsDiff = false;
        //        StepListA[j].IsExtra = true;
        //        StepListA[j].InvokePropertyChanged();
        //        foreach (var pa in _mapStepParamA[StepListA[j].StepNumber])
        //        {
        //            pa.InvokePropertyChanged();
        //        }
        //    }

        //    for (int k = i; k < StepListB.Count; k++)
        //    {
        //        StepListB[k].IsDiff = false;
        //        StepListB[k].IsExtra = true;
        //        WholeListB[k].InvokePropertyChanged();
        //        _mapLineTextB[WholeListB[k].LineNumber].InvokePropertyChanged();
        //        foreach (var pb in _mapStepParamB[StepListB[k].StepNumber])
        //        {
        //            pb.InvokePropertyChanged();
        //        }
        //    }
        //    NotifyOfPropertyChange(nameof(StepListA));
        //    NotifyOfPropertyChange(nameof(StepListB));
        //}

        private void RecompareWhole()
        {
            if (WholeListA == null || WholeListB == null)
                return;
            int i = 0;
            for (i = 0; i < WholeListA.Count && i < WholeListB.Count; i++)
            {
                LineDataItem lineA = _mapLineTextA[WholeListA[i].LineNumber];
                LineDataItem lineB = _mapLineTextB[WholeListB[i].LineNumber];
                bool isDiff = false;

                lineB.IsDiff = lineA.IsDiff = (lineA.LineText != lineB.LineText);
                if (lineA.IsDiff)
                    isDiff = true;

                WholeListA[i].IsDiff = WholeListB[i].IsDiff = isDiff;
                WholeListA[i].IsExtra = WholeListB[i].IsExtra = false;

                _mapLineTextA[WholeListA[i].LineNumber].IsDiff = _mapLineTextB[WholeListB[i].LineNumber].IsDiff = isDiff;
                _mapLineTextA[WholeListA[i].LineNumber].IsExtra = _mapLineTextB[WholeListB[i].LineNumber].IsExtra = false;

                lineA.InvokePropertyChanged();
                lineB.InvokePropertyChanged();
                WholeListA[i].InvokePropertyChanged();
                WholeListB[i].InvokePropertyChanged();

            }

            for (int j = i; j < WholeListA.Count; j++)
            {
                WholeListA[j].IsDiff = false;
                WholeListA[j].IsExtra = true;

                _mapLineTextA[WholeListA[j].LineNumber].IsDiff = false;
                _mapLineTextA[WholeListA[j].LineNumber].IsExtra = true;

                if (!(_mapLineTextA[WholeListA[j].LineNumber].LineText.Contains("<Step StepNo") || _mapLineTextA[WholeListA[j].LineNumber].LineText.Contains("<Moudule Name")))
                {
                    WholeListA[j].IsDiff = false;
                    WholeListA[j].IsExtra = false;
                }

                WholeListA[j].InvokePropertyChanged();
                _mapLineTextA[WholeListA[j].LineNumber].InvokePropertyChanged();
            }

            for (int k = i; k < WholeListB.Count; k++)
            {
                WholeListB[k].IsDiff = false;
                WholeListB[k].IsExtra = true;

                _mapLineTextB[WholeListB[k].LineNumber].IsDiff = false;
                _mapLineTextB[WholeListB[k].LineNumber].IsExtra = true;

                if (!(_mapLineTextB[WholeListB[k].LineNumber].LineText.Contains("<Step StepNo") || _mapLineTextB[WholeListB[k].LineNumber].LineText.Contains("<Moudule Name")))
                {
                    WholeListB[k].IsDiff = false;
                    WholeListB[k].IsExtra = false;
                }

                WholeListB[k].InvokePropertyChanged();
                _mapLineTextB[WholeListB[k].LineNumber].InvokePropertyChanged();
            }
            NotifyOfPropertyChange(nameof(WholeListA));
            NotifyOfPropertyChange(nameof(WholeListB));
        }

        private void SyncStepSelection(TwoStepDataItem stepData)
        {
            if (stepData == null)
                return;

            var getStepA = StepListA.Where(x => x.StepName == stepData.AStepName).FirstOrDefault();
            var getStepB = StepListB.Where(x => x.StepName == stepData.BStepName).FirstOrDefault();
            if (getStepA == null && getStepB == null)
            {
                ParamList.Clear();
                return;
            }
            else if (getStepA != null && getStepB == null)
            {
                ParamListA = _mapStepParamA[getStepA.StepNumber];

                foreach (var item in ParamListA)
                {
                    var par = ParamList.FirstOrDefault(x => x.ParamName == item.ParamName);
                    if (par != null)
                    {
                        par.AParamValue = item.ParamValue;
                        par.IsDiff = false;
                        par.IsExtra = item.IsExtra;
                        par.BParamValue = "--";
                    }
                    else
                    {
                        TwoParamDataItem param = new TwoParamDataItem();
                        param.ParamName = item.ParamName;
                        param.AParamValue = item.ParamValue;
                        param.IsDiff = item.IsDiff;
                        param.IsExtra = item.IsExtra;
                        param.BParamValue = "--";
                        ParamList.Add(param);
                    }
                }
            }
            else if (getStepA == null && getStepB != null)
            {
                ParamListB = _mapStepParamB[getStepB.StepNumber];
                foreach (var item in ParamListB)
                {
                    var par = ParamList.FirstOrDefault(x => x.ParamName == item.ParamName);
                    if (par != null)
                    {
                        par.BParamValue = item.ParamValue;
                        par.IsDiff = false;
                        par.IsExtra = item.IsExtra;
                        par.AParamValue = "--";
                    }
                    else
                    {
                        var param = new TwoParamDataItem();
                        param.ParamName = item.ParamName;
                        param.BParamValue = item.ParamValue;
                        param.IsDiff = item.IsDiff;
                        param.IsExtra = item.IsExtra;
                        param.AParamValue = "--";
                        ParamList.Add(param);
                    }
                }
            }
            else
            {
                ParamListA = _mapStepParamA[getStepA.StepNumber];
                ParamListB = _mapStepParamB[getStepB.StepNumber];
                foreach (var item in ParamListA)
                {
                    var bValue = ParamListB.FirstOrDefault(x => x.ParamName == item.ParamName)?.ParamValue;

                    var par = ParamList.FirstOrDefault(x => x.ParamName == item.ParamName);
                    if (par != null)
                    {
                        par.AParamValue = item.ParamValue;
                        par.IsDiff = item.IsDiff;
                        par.IsExtra = item.IsExtra;
                        if (bValue != null)
                        {
                            par.BParamValue = bValue;
                        }
                        else
                        {
                            par.BParamValue = "--";
                        }
                    }
                    else
                    {
                        var param = new TwoParamDataItem();
                        param.ParamName = item.ParamName;
                        param.AParamValue = item.ParamValue;
                        param.IsDiff = item.IsDiff;
                        param.IsExtra = item.IsExtra;
                        if (bValue != null)
                        {
                            param.BParamValue = bValue;
                        }
                        else
                        {
                            param.BParamValue = "--";
                        }
                        ParamList.Add(param);
                    }
                }
            }
            //NotifyOfPropertyChange(nameof(StepSelection));
            //StepSelection.InvokePropertyChanged();
        }

        private void SyncTableStepSelection(TwoStepDataItem stepData)
        {
            if (stepData == null)
                return;

            var getStepA = tableStepListA[SelectTableIndex].Where(x => x.StepName == stepData.AStepName).FirstOrDefault();
            var getStepB = tableStepListB[SelectTableIndex].Where(x => x.StepName == stepData.BStepName).FirstOrDefault();
            if (getStepA == null && getStepB == null)
            {
                ParamList.Clear();
                return;
            }
            else if (getStepA != null && getStepB == null)
            {
                var tempPar = _mapTableStepParamA.Keys.FirstOrDefault(x => x.TableIndex == SelectTableIndex.ToString());
                ParamListA.Clear();
                if (tempPar != null)
                {
                    _mapTableStepParamA[tempPar][getStepA.StepNumber].ToList().ForEach(x => ParamListA.Add(x));
                }
                foreach (var item in ParamListA)
                {
                    var par = ParamList.FirstOrDefault(x => x.ParamName == item.ParamName);
                    if (par != null)
                    {
                        par.AParamValue = item.ParamValue;
                        par.IsDiff = false;
                        par.IsExtra = item.IsExtra;
                        par.BParamValue = "--";
                    }
                    else
                    {
                        TwoParamDataItem param = new TwoParamDataItem();
                        param.ParamName = item.ParamName;
                        param.AParamValue = item.ParamValue;
                        param.IsDiff = item.IsDiff;
                        param.IsExtra = item.IsExtra;
                        param.BParamValue = "--";
                        ParamList.Add(param);
                    }
                }
            }
            else if (getStepA == null && getStepB != null)
            {
                var tempPar = _mapTableStepParamB.Keys.FirstOrDefault(x => x.TableIndex == SelectTableIndex.ToString());
                ParamListB.Clear();
                if (tempPar != null)
                {
                    _mapTableStepParamB[tempPar][getStepB.StepNumber].ToList().ForEach(x => ParamListB.Add(x));
                }
                foreach (var item in ParamListB)
                {
                    var par = ParamList.FirstOrDefault(x => x.ParamName == item.ParamName);
                    if (par != null)
                    {
                        par.BParamValue = item.ParamValue;
                        par.IsDiff = false;
                        par.IsExtra = item.IsExtra;
                        par.AParamValue = "--";
                    }
                    else
                    {
                        var param = new TwoParamDataItem();
                        param.ParamName = item.ParamName;
                        param.BParamValue = item.ParamValue;
                        param.IsDiff = item.IsDiff;
                        param.IsExtra = item.IsExtra;
                        param.AParamValue = "--";
                        ParamList.Add(param);
                    }
                }
            }
            else
            {
                var tempPar = _mapTableStepParamA.Keys.FirstOrDefault(x => x.TableIndex == SelectTableIndex.ToString());
                ParamListA.Clear();
                if (tempPar != null)
                {
                    _mapTableStepParamA[tempPar][getStepA.StepNumber].ToList().ForEach(x => ParamListA.Add(x));
                }
                var tempParB = _mapTableStepParamB.Keys.FirstOrDefault(x => x.TableIndex == SelectTableIndex.ToString());
                ParamListB.Clear();
                if (tempParB != null)
                {
                    _mapTableStepParamB[tempParB][getStepB.StepNumber].ToList().ForEach(x => ParamListB.Add(x));
                }
                foreach (var item in ParamListA)
                {
                    var bValue = ParamListB.FirstOrDefault(x => x.ParamName == item.ParamName)?.ParamValue;

                    var par = ParamList.FirstOrDefault(x => x.ParamName == item.ParamName);
                    if (par != null)
                    {
                        par.AParamValue = item.ParamValue;

                        par.IsExtra = item.IsExtra;
                        if (bValue != null)
                        {
                            par.IsDiff = item.ParamValue != bValue;
                            par.BParamValue = bValue;
                        }
                        else
                        {
                            par.BParamValue = "--";
                        }
                    }
                    else
                    {
                        var param = new TwoParamDataItem();
                        param.ParamName = item.ParamName;
                        param.AParamValue = item.ParamValue;
                        param.IsDiff = item.IsDiff;
                        param.IsExtra = item.IsExtra;
                        if (bValue != null)
                        {
                            param.BParamValue = bValue;
                        }
                        else
                        {
                            param.BParamValue = "--";
                        }
                        ParamList.Add(param);
                    }
                }
            }
            //NotifyOfPropertyChange(nameof(StepSelection));
            //StepSelection.InvokePropertyChanged();
        }

        private void SyncParamSelection(ParamDataItem paramData, bool isSelectA)
        {
            try
            {
                if (paramData == null)
                    return;

                if (isSelectA)
                {
                    if (IsCompareBySName)
                    {
                        //var getSameStepName = StepListA.Where(x => x.StepName == StepSelectionB.StepName).FirstOrDefault();
                        //if (getSameStepName == null) return;
                        //if (_mapStepParamA.ContainsKey(getSameStepName.StepNumber))
                        //{
                        //    ParamListA = _mapStepParamA[getSameStepName.StepNumber];
                        //    NotifyOfPropertyChange(nameof(ParamListA));
                        //}
                        //else
                        //    return;
                        //foreach (var item in ParamListA)
                        //{
                        //    if (item.ParamName == paramData.ParamName)
                        //    {
                        //        _paramSelectionA = item;
                        //        NotifyOfPropertyChange(nameof(ParamSelectionA));
                        //        ParamSelectionA.InvokePropertyChanged();
                        //    }
                        //}
                    }
                }
                else
                {
                    //if (IsCompareByStep)
                    //{
                    //    if (ParamListB == null)
                    //    {
                    //        if (_mapStepParamB.ContainsKey(StepSelectionA.StepNumber))
                    //        {
                    //            ParamListB = _mapStepParamB[StepSelectionA.StepNumber];
                    //            NotifyOfPropertyChange(nameof(ParamListB));
                    //        }
                    //        else
                    //            return;
                    //    }
                    //    foreach (var item in ParamListB)
                    //    {
                    //        if (item.ParamName == paramData.ParamName)
                    //        {
                    //            _paramSelectionB = item;
                    //            NotifyOfPropertyChange(nameof(ParamSelectionB));
                    //            ParamSelectionB.InvokePropertyChanged();
                    //        }
                    //    }
                    //}
                    //if (IsCompareBySName)
                    //{
                    //    if (ParamListB == null)
                    //    {
                    //        var getSameStepName = StepListB.Where(x => x.StepName == StepSelectionA.StepName).FirstOrDefault();
                    //        if (_mapStepParamB.ContainsKey(getSameStepName.StepNumber))
                    //        {
                    //            ParamListB = _mapStepParamB[getSameStepName.StepNumber];
                    //            NotifyOfPropertyChange(nameof(ParamListB));
                    //        }
                    //        else
                    //            return;
                    //    }
                    //    foreach (var item in ParamListB)
                    //    {
                    //        if (item.ParamName == paramData.ParamName)
                    //        {
                    //            _paramSelectionB = item;
                    //            NotifyOfPropertyChange(nameof(ParamSelectionB));
                    //            ParamSelectionB.InvokePropertyChanged();
                    //        }
                    //    }
                    //}
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex.Message);
            }
        }

        private void SyncLineSelection(LineDataItem lineData, bool isSelectA)
        {
            if (lineData == null)
                return;

            if (isSelectA)
            {
                foreach (var item in WholeListA)
                {
                    if (item.LineNumber == lineData.LineNumber)
                    {
                        _lineSelectionA = item;
                        NotifyOfPropertyChange(nameof(LineSelectionA));
                        LineSelectionA.InvokePropertyChanged();
                    }
                }
            }
            else
            {
                foreach (var item in WholeListB)
                {
                    if (item.LineNumber == lineData.LineNumber)
                    {
                        _lineSelectionB = item;
                        NotifyOfPropertyChange(nameof(LineSelectionB));
                        LineSelectionB.InvokePropertyChanged();
                    }
                }
            }
        }

        public void RemoveA()
        {
            RemoveRecipe(true);


        }

        public void RemoveB()
        {
            RemoveRecipe(false);

        }

        private void RemoveSelectB()
        {
            StepListB?.Clear();
            ParamListB?.Clear();
            WholeListB?.Clear();
            RecipeB = string.Empty;
            _mapStepParamB?.Clear();
            _paramSelectionB = null;
            NotifyOfPropertyChange(nameof(StepListB));
            NotifyOfPropertyChange(nameof(ParamListB));
            NotifyOfPropertyChange(nameof(RecipeB));
            NotifyOfPropertyChange(nameof(EnableButtonRemoveB));
            NotifyOfPropertyChange(nameof(ParamSelectionB));
        }

        private void RemoveRecipe(bool isSelectA)
        {
            if (!DialogBox.Confirm($"Are you sure you want to remove the recipe? \r\n{RecipeB}"))
                return;

            if (isSelectA)
            {
                StepListA?.Clear();
                ParamListA?.Clear();
                WholeListA?.Clear();
                RecipeA = string.Empty;
                _mapStepParamA?.Clear();

                NotifyOfPropertyChange(nameof(StepListA));
                NotifyOfPropertyChange(nameof(ParamListA));
                NotifyOfPropertyChange(nameof(RecipeA));
                NotifyOfPropertyChange(nameof(EnableButtonRemoveA));
            }
            else
            {
                StepListB?.Clear();
                ParamListB?.Clear();
                WholeListB?.Clear();
                RecipeB = string.Empty;
                _mapStepParamB?.Clear();
                _paramSelectionB = null;

                NotifyOfPropertyChange(nameof(StepListB));
                NotifyOfPropertyChange(nameof(ParamListB));
                NotifyOfPropertyChange(nameof(RecipeB));
                NotifyOfPropertyChange(nameof(EnableButtonRemoveB));
                NotifyOfPropertyChange(nameof(ParamSelectionB));
            }
        }


        private void DeleteInnerXml(bool isSelectA)
        {
            try
            {
                XmlDocument docTo = isSelectA ? _domA : _domB;
                //XmlNode nodeModule = docTo.SelectSingleNode($"Aitex/TableRecipeData/Module[@Name='PM1']");{_module}
                //                        doc.SelectNodes($"Aitex/TableRecipeData/Module[@Name='PM1']/Step");
                XmlNodeList nodeSteps = docTo.SelectNodes($"Aitex/TableRecipeData/Module[@Name='PM1']/Step");
                if (nodeSteps == null)
                    nodeSteps = docTo.SelectNodes($"Aitex/TableRecipeData/Step");
                List<XmlNode> oldNodeSteps = new List<XmlNode>();
                foreach (XmlNode nodeTemp in nodeSteps)
                {
                    oldNodeSteps.Add(nodeTemp.Clone());
                }

                XmlNodeList backSteps = docTo.SelectNodes($"Aitex/TableRecipeData/Module[@Name='PM1']/BakeStep");
                if (backSteps == null)
                    backSteps = docTo.SelectNodes($"Aitex/TableRecipeData/BakeStep");
                List<XmlNode> oldBackNodeSteps = new List<XmlNode>();
                foreach (XmlNode nodeTemp in backSteps)
                {
                    oldBackNodeSteps.Add(nodeTemp.Clone());
                }

                XmlNode stepsNode = docTo.SelectSingleNode($"Aitex/TableRecipeData/Module[@Name='PM1']/Step").ParentNode;

                stepsNode.RemoveAll();
                (stepsNode as XmlElement).SetAttribute("Name", "PM1");  //微釜的recipe为什么都是PM1？，如果recipe改了，此处要改回(stepsNode as XmlElement).SetAttribute("Name", _module);

                ObservableCollection<StepDataItem> stepListTo = isSelectA ? StepListA : StepListB;

                if (stepsNode == null)
                {
                    return;
                }

                foreach (StepDataItem item in stepListTo)
                {
                    XmlElement DeviceTree = docTo.CreateElement("Step");
                    DeviceTree.SetAttribute("StepNo", item.StepNumber.ToString());
                    DeviceTree.SetAttribute("Name", item.StepName);
                    stepsNode.AppendChild(DeviceTree);
                }

                foreach (XmlNode nodeStep in stepsNode)
                {
                    string stepNumber = nodeStep.Attributes["StepNo"].Value;

                    ObservableCollection<ParamDataItem> paramList =
                        isSelectA ? _mapStepParamA[stepNumber] : _mapStepParamB[stepNumber];
                    foreach (var param in paramList)
                    {
                        (nodeStep as XmlElement).SetAttribute(param.ParamName, param.ParamValue);
                    }
                }

                foreach (XmlNode nodeStep in backSteps)
                {
                    stepsNode.AppendChild(nodeStep);
                }

                string backText = getXmlText(isSelectA ? _domA : _domB);
                LoadrecipeContentData(backText, isSelectA);
                Recompare();

                SyncShowDiffSteps(IsShowDiffSteps);
                if (isSelectA)
                {
                    BackInnerXmlTextA.Add(backText);
                }
                else
                {
                    BackInnerXmlTextB.Add(backText);
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex.Message);
            }
        }



        public void SelectedRecipeTable()
        {
            ItemsSelectDialogViewModel itemsSelectDialogViewModel = new ItemsSelectDialogViewModel();
            itemsSelectDialogViewModel.Items.Clear();
            var tables = _mapTableStepParamA.Keys;
            foreach (var item in tables)
            {
                TwoTableDataItem twoTableDataItem = new TwoTableDataItem();
                int tableIndex = -1;
                int.TryParse(item.TableIndex, out tableIndex);
                if (tableIndex != -1)
                {
                    twoTableDataItem.Index = tableIndex;
                    twoTableDataItem.ATableName = item.TableName;
                    var tablesB = _mapTableStepParamB.Keys;
                    var tableB = tablesB.FirstOrDefault(x => x.TableIndex == item.TableIndex);
                    if (tableB != null)
                    {
                        twoTableDataItem.BTableName = tableB.TableName;
                        twoTableDataItem.IsDiff = tableB.IsDiff;
                    }
                    itemsSelectDialogViewModel.Items.Add(twoTableDataItem);
                }
            }
            WindowManager wm = new WindowManager();
            bool? bret = wm.ShowDialog(itemsSelectDialogViewModel);
            if ((bool)bret)
            {
                var item = itemsSelectDialogViewModel.SelectedItem;
                SelectedTwoTableData = item;
                SelectTableIndex = item.Index;
                GetTableStepList(true, item.Index);
                GetTableStepList(false, item.Index);
                SyncShowDiffSteps(IsShowDiffSteps);
                if (StepList != null && StepList.Count > 0)
                    SyncTableStepSelection(StepList[0]);
                SyncShowDiffParams(_isShowDiffParams);
            }
        }


        private string getXmlText(XmlDocument xmlDocument)
        {
            (new RecipeProvider()).SaveRecipe("", "RecipeTemp", xmlDocument.InnerXml);

            var _recipeProvider = new RecipeProvider();
            var recipeContent = _recipeProvider.LoadRecipe("", "RecipeTemp", false);
            return recipeContent;
        }


        public void LineCopyToLeft(LineDataItem lineData)
        {
            LineCopy(lineData, false);
        }

        public void LineCopyToRight(LineDataItem lineData)
        {
            LineCopy(lineData, true);
        }

        public void LineCopy(LineDataItem lineData, bool isFromA)
        {
            try
            {
                LineDataItem lineFrom = lineData;
                ObservableCollection<LineDataItem> lineListTo = isFromA ? WholeListB : WholeListA;

                Dictionary<string, LineDataItem> mapFrom = isFromA ? _mapLineTextA : _mapLineTextB;
                Dictionary<string, LineDataItem> mapTo = isFromA ? _mapLineTextB : _mapLineTextA;

                var tempLine = lineListTo.Where(x => x.LineNumber == lineFrom.LineNumber).FirstOrDefault();
                if (tempLine != null)
                {
                    tempLine.LineText = lineFrom.LineText;
                    tempLine.IsDiff = lineFrom.IsDiff = false;
                    tempLine.IsExtra = lineFrom.IsExtra = false;
                }

                string recipeContent = "";
                if (isFromA)
                {
                    for (int i = 0; i < WholeListB.Count; i++)
                    {
                        recipeContent += WholeListB[i].LineText + ((i == WholeListB.Count - 1) ? "" : "\r\n");
                    }
                }
                else
                {
                    for (int i = 0; i < WholeListA.Count; i++)
                    {
                        recipeContent += WholeListA[i].LineText + ((i == WholeListB.Count - 1) ? "" : "\r\n");
                    }
                }

                CopyToInnerXml(recipeContent, !isFromA);
                LoadrecipeContentData(recipeContent, !isFromA);
                Recompare();
                SyncShowDiffSteps(IsShowDiffSteps);
            }
            catch (Exception ex)
            {
                LOG.Write(ex.Message);
            }
        }

        private void CopyToInnerXml(string recipeContent, bool isSelectA)
        {
            XmlDocument doc = isSelectA ? _domA : _domB;
            doc.InnerXml = recipeContent;
            if (isSelectA)
            {
                BackInnerXmlTextA.Add(recipeContent);
            }
            else
            {
                BackInnerXmlTextB.Add(recipeContent);
            }
        }

        public void SaveA()
        {
            Save(true);
        }

        public void SaveB()
        {
            Save(false);
        }

        private void Save(bool isSelectA)
        {
            XmlDocument doc = isSelectA ? _domA : _domB;
            XmlNodeList nodeSteps = doc.SelectNodes($"Aitex/TableRecipeData/Module[@Name='PM1']/Step");
            if (nodeSteps == null)
                nodeSteps = doc.SelectNodes($"Aitex/TableRecipeData/Step");

            if (isSelectA)
            {
                (new RecipeProvider()).SaveRecipe("", RecipeA, doc.InnerXml);
            }
            else
            {
                (new RecipeProvider()).SaveRecipe("", RecipeB, doc.InnerXml);
            }
        }

        private bool _isStepModel = true;
        public bool IsStepModel
        {
            get { return _isStepModel; }
            set
            {
                _isStepModel = value;
                _isWholeModel = !_isStepModel;
                StepVisibility = _isStepModel ? Visibility.Visible : Visibility.Hidden;
                WholeVisibility = _isWholeModel ? Visibility.Visible : Visibility.Hidden;
                InvokePropertyChanged(nameof(IsStepModel));
                InvokePropertyChanged(nameof(IsWholeModel));

                InvokePropertyChanged(nameof(StepVisibility));
                InvokePropertyChanged(nameof(WholeVisibility));
            }
        }


        private bool _isWholeModel;
        public bool IsWholeModel
        {
            get { return _isWholeModel; }
            set
            {
                _isWholeModel = value;
                _isStepModel = !_isWholeModel;
                StepVisibility = _isStepModel ? Visibility.Visible : Visibility.Hidden;
                WholeVisibility = _isWholeModel ? Visibility.Visible : Visibility.Hidden;
                InvokePropertyChanged(nameof(IsWholeModel));
                InvokePropertyChanged(nameof(IsStepModel));

                InvokePropertyChanged(nameof(StepVisibility));
                InvokePropertyChanged(nameof(WholeVisibility));
            }
        }

        public Visibility StepVisibility
        {
            get; set;
        }
        public Visibility WholeVisibility
        {
            get; set;
        }

        private bool _isShowDiffSteps;
        public bool IsShowDiffSteps
        {
            get { return _isShowDiffSteps; }
            set
            {
                _isShowDiffSteps = value;
                _isShowAllSteps = !_isShowDiffSteps;
                SyncShowDiffSteps(_isShowDiffSteps);
                InvokePropertyChanged(nameof(IsShowDiffSteps));
                InvokePropertyChanged(nameof(IsShowAllSteps));
            }
        }


        private bool _isShowAllSteps = true;
        public bool IsShowAllSteps
        {
            get { return _isShowAllSteps; }
            set
            {
                _isShowAllSteps = value;
                _isShowDiffSteps = !_isShowAllSteps;

                SyncShowDiffSteps(_isShowDiffSteps);

                InvokePropertyChanged(nameof(IsShowAllSteps));
                InvokePropertyChanged(nameof(IsShowDiffSteps));
            }
        }


        private bool _isShowDiffParams;
        public bool IsShowDiffParams
        {
            get { return _isShowDiffParams; }
            set
            {
                _isShowDiffParams = value;
                SyncShowDiffParams(_isShowDiffParams);
                _isShowAllParams = !_isShowDiffParams;
                InvokePropertyChanged(nameof(IsShowDiffParams));
                InvokePropertyChanged(nameof(IsShowAllParams));
            }
        }


        private bool _isShowAllParams = true;
        public bool IsShowAllParams
        {
            get { return _isShowAllParams; }
            set
            {
                _isShowAllParams = value;
                _isShowDiffParams = !_isShowAllParams;
                SyncShowDiffParams(_isShowDiffParams);
                InvokePropertyChanged(nameof(IsShowDiffParams));
                InvokePropertyChanged(nameof(IsShowAllParams));
            }
        }

        private bool _isCompareBySName = true;
        public bool IsCompareBySName
        {
            get { return _isCompareBySName; }
            set
            {
                _isCompareBySName = value;
                Recompare();
                SyncShowDiffSteps(_isShowDiffSteps);
                InvokePropertyChanged(nameof(IsCompareBySName));
            }
        }

        private void SyncShowDiffSteps(bool isShowDiffSteps)
        {
            if (StepListA == null || StepListB == null)
                return;

            foreach (var item in StepList)
            {
                item.IsHidden = (IsShowDiffSteps ? (item.IsDiff == false && item.IsExtra == false) : false);
            }
            NotifyOfPropertyChange(nameof(StepList));
        }

        private void SyncShowDiffParams(bool isShowDiffParams)
        {
            if (ParamListA == null || ParamListB == null)
                return;

            if (isShowDiffParams)
            {
                foreach (var item in ParamList)
                {
                    if (item.IsDiff == false && item.IsExtra == false)
                    {
                        item.IsHidden = isShowDiffParams;
                    }
                    else
                    {
                        item.IsHidden = false;
                    }
                }
            }
            else
            {
                foreach (var item in ParamList)
                {
                    item.IsHidden = isShowDiffParams;
                }
            }
            NotifyOfPropertyChange(nameof(ParamList));
        }
    }
}