using Aitex.Core.RT.Log;
using Caliburn.Micro.Core;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.ParameterCenter;
using MECF.Framework.Common.RecipeCenter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using RecipeEditorLib.DGExtension.CustomColumn;
using RecipeEditorLib.RecipeModel.Params;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Xml;

namespace MECF.Framework.UI.Client.CenterViews.Parameter
{
    public class ParameterDataBase : PropertyChangedBase
    {
        public bool IsChanged
        {
            get
            {
                bool changed = !IsSavedDesc;

                if (!changed)
                {
                    //changed = ChkChanged(Steps) || ChkChanged(PopSettingSteps) || ChkChanged(StepTolerances);
                }

                if (!changed)
                {
                    foreach (Param config in this.ConfigItems)
                    {
                        if (!config.IsSaved)
                        {
                            changed = true;
                            break;
                        }
                    }
                }
                return changed;
            }
        }

        private bool _isSavedDesc;
        public bool IsSavedDesc
        {
            get { return _isSavedDesc; }
            set
            {
                this._isSavedDesc = value;
                this.NotifyOfPropertyChange("IsSavedDesc");
            }
        }

        private string name;
        public string Name
        {
            get { return this.name; }
            set
            {
                this.name = value;
                this.NotifyOfPropertyChange("Name");
            }
        }

        private string _chamberType;
        public string ChamberType
        {
            get { return this._chamberType; }
            set
            {
                this._chamberType = value;
                this.NotifyOfPropertyChange("ChamberType");
            }
        }

        private string _version;
        public string Version
        {
            get { return this._version; }
            set
            {
                this._version = value;
                this.NotifyOfPropertyChange("Version");
            }
        }

        private int _tableNumber;
        public int TableNumber
        {
            get { return this._tableNumber; }
            set
            {
                this._tableNumber = value;
                this.NotifyOfPropertyChange("TableNumber");
            }
        }

        private string _permission;
        public string Permission
        {
            get { return this._permission; }
            set
            {
                this._permission = value;
                this.NotifyOfPropertyChange("Permission");
            }
        }
        private string _level;
        public string Level
        {
            get { return this._level; }
            set
            {
                this._level = value;
                this.NotifyOfPropertyChange("Level");
            }
        }
        private string _prefixPath;
        public string PrefixPath
        {
            get { return _prefixPath; }
            set
            {
                _prefixPath = value;
                this.NotifyOfPropertyChange("PrefixPath");
            }
        }

        private string creator;
        public string Creator
        {
            get { return this.creator; }
            set
            {
                this.creator = value;
                this.NotifyOfPropertyChange("Creator");
            }
        }

        private DateTime createTime;
        public DateTime CreateTime
        {
            get { return this.createTime; }
            set
            {
                this.createTime = value;
                this.NotifyOfPropertyChange("CreateTime");
            }
        }

        private string description;
        public string Description
        {
            get { return this.description; }
            set
            {
                this.description = value;
                this.NotifyOfPropertyChange("Description");
            }
        }

        private string devisor;
        public string Revisor
        {
            get { return this.devisor; }
            set
            {
                this.devisor = value;
                this.NotifyOfPropertyChange("Revisor");
            }
        }

        private DateTime deviseTime;
        public DateTime ReviseTime
        {
            get { return this.deviseTime; }
            set
            {
                this.deviseTime = value;
                this.NotifyOfPropertyChange("ReviseTime");
            }
        }
        public ObservableCollection<ParameterTable> Steps { get; private set; }

        public Dictionary<string, ObservableCollection<ObservableCollection<Param>>> PopSettingSteps { get; private set; }

        public ObservableCollection<ObservableCollection<Param>> StepTolerances { get; private set; }

        public ObservableCollection<Param> ConfigItems { get; private set; }

        public List<int> StepNos = new List<int>();

        protected XmlDocument _doc;
        protected string _module;

        public bool ToleranceEnable { get; set; }
        public Dictionary<string, bool> PopEnable { get; set; }

        public bool IsCompatibleWithCurrentFormat { get; set; }





        public bool ChkChanged(Dictionary<string, ObservableCollection<ObservableCollection<Param>>> PopSteps)
        {

            return false;
        }

        public void CloneStep(ref ParameterTable destinationStep, ParameterTable originalStep)
        {
            //destinationStep.StepNo = originalStep.StepNo;
            destinationStep.Name = originalStep.Name;
         //   destinationStep.UseTemp = originalStep.UseTemp;
        }

        public void CloneStep(ParameterTable destinationStep, ParameterTable originalStep)
        {
            //destinationStep.StepNo = originalStep.StepNo;
            destinationStep.Name = originalStep.Name;
          //  destinationStep.UseTemp = originalStep.UseTemp;
        }

        public ParameterDataBase()
        {
            this.Steps = new ObservableCollection<ParameterTable>();
            StepTolerances = new ObservableCollection<ObservableCollection<Param>>();
            this.PopSettingSteps = new Dictionary<string, ObservableCollection<ObservableCollection<Param>>>();
            this.PopEnable = new Dictionary<string, bool>();
            ConfigItems = new ObservableCollection<Param>();
            IsSavedDesc = true;

            _doc = new XmlDocument();
            XmlElement node = _doc.CreateElement("Aitex");
            _doc.AppendChild(node);
            node.AppendChild(_doc.CreateElement("TableParameterData"));


        }

        public void Clear()
        {
            Steps.Clear();
            PopSettingSteps.Clear();
            StepTolerances.Clear();
            ConfigItems.Clear();

            ChamberType = "";
            Version = "";
            IsSavedDesc = true;
            _module = "";
        }

        public void DataSaved()
        {
            //foreach (Step parameters in Steps)
            //{
            //    parameters.Apply(param => param.IsSaved = true);
            //}

            //foreach (ObservableCollection<ObservableCollection<Param>> popParameters in PopSettingSteps.Values)
            //{
            //    foreach (ObservableCollection<Param> parameters in popParameters)
            //    {
            //        parameters.Apply(param => param.IsSaved = true);
            //    }
            //}

            //foreach (ObservableCollection<Param> parameters in StepTolerances)
            //{
            //    parameters.Apply(param => param.IsSaved = true);
            //}

            //ConfigItems.Apply(config => config.IsSaved = true);

            //IsSavedDesc = true;
        }

        public virtual void InitData(string prefixPath, string recipeName, string recipeContent, string module)
        {
            IsCompatibleWithCurrentFormat = false;
            _module = module;
            Name = recipeName;
            PrefixPath = prefixPath;
            try
            {
                _doc = new XmlDocument();
                _doc.LoadXml(recipeContent);

                if (!LoadHeader(_doc.SelectSingleNode("Aitex/TableParameterData")))
                    return;

                XmlNodeList nodeSteps = _doc.SelectNodes($"Aitex/TableParameterData/Module[@Name='{module}']/Step");
                if (nodeSteps == null)
                    nodeSteps = _doc.SelectNodes($"Aitex/TableParameterData/Step");

                LoadSteps(nodeSteps);

                var index = 1;
                foreach (ParameterTable parameters in Steps)
                {
                    parameters.Value = index.ToString();
                    index++;
                }

                //   ValidLoopData();

                XmlNode nodeConfig =
                    _doc.SelectSingleNode($"Aitex/TableParameterData/Module[@Name='{module}']/Config");
                if (nodeSteps == null)
                    nodeConfig = _doc.SelectSingleNode($"Aitex/TableParameterData/Config");

                //   LoadConfigs(configDefine, nodeConfig);

                IsCompatibleWithCurrentFormat = true;
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }

        public void ChangeChamber(ObservableCollection<EditorDataGridTemplateColumnBase> columnDefine, Dictionary<string, ObservableCollection<Param>> PopSettingColumns
            , ObservableCollection<Param> configDefine, string module)
        {
            _module = module;
            try
            {
                XmlNodeList nodeSteps = _doc.SelectNodes($"Aitex/TableParameterData/Module[@Name='{module}']/Step");
                if (nodeSteps == null)
                    nodeSteps = _doc.SelectNodes($"Aitex/TableParameterData/Step");

                LoadSteps(nodeSteps);



                XmlNode nodeConfig =
                    _doc.SelectSingleNode($"Aitex/TableParameterData/Module[@Name='{module}']/Config");
                if (nodeSteps == null)
                    nodeConfig = _doc.SelectSingleNode($"Aitex/TableParameterData/Config");

                LoadConfigs(configDefine, nodeConfig);
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }

        public void SaveTo(string[] moduleList)
        {
            GetXmlString();

            XmlNode nodeModule = _doc.SelectSingleNode($"Aitex/TableParameterData/Module[@Name='{_module}']");
            if (nodeModule == null)
            {
                LOG.Write("Parameter not find modules," + Name);
                return;
            }

            XmlNode nodeData = nodeModule.ParentNode;

            foreach (var module in moduleList)
            {
                if (module == _module)
                {
                    continue;
                }

                var child = _doc.SelectSingleNode($"Aitex/TableParameterData/Module[@Name='{module}']");
                if (child != null)
                    nodeData.RemoveChild(child);

                XmlElement node = nodeModule.Clone() as XmlElement;
                node.SetAttribute("Name", module);
                nodeData.AppendChild(node);
            }
        }

       protected int StepNo = 1;


        public Dictionary<string, string> StepTimeToDictionary(string stepTime)
        {
            Dictionary<string, string> steptimes = new Dictionary<string, string>();
            string[] tempTimes = stepTime.Split(';');
            foreach (var item in tempTimes)
            {
                string[] subTimes = item.Split(',');
                steptimes.Add(subTimes[0], subTimes[1]);
            }
            return steptimes;
        }

        public virtual ParameterTable CreateStep(XmlNode stepNode = null)
        {
            ParameterTable step = new ParameterTable();
            if (stepNode != null)
            {
                if (stepNode.Attributes["StepNo"] != null)
                    step.StepNo = int.Parse(stepNode.Attributes["StepNo"].Value);
                if (stepNode.Attributes["Name"] != null)
                    step.Name = stepNode.Attributes["Name"].Value;
                //if (stepNode.Attributes["UseTemp"] != null)
                //    step.UseTemp = stepNode.Attributes["UseTemp"].Value;
            }
            else
            {
                step.StepNo = StepNo;
                step.Name = "Name" + StepNo.ToString();
               // step.UseTemp = "0";
                StepNo++;
            }
            return step;
        }

        protected bool LoadHeader(XmlNode nodeHeader)
        {
            if (nodeHeader == null)
                return false;

            if (nodeHeader.Attributes["CreatedBy"] != null)
                this.Creator = nodeHeader.Attributes["CreatedBy"].Value;
            if (nodeHeader.Attributes["CreationTime"] != null)
                this.CreateTime = DateTime.Parse(nodeHeader.Attributes["CreationTime"].Value);
            if (nodeHeader.Attributes["LastRevisedBy"] != null)
                this.Revisor = nodeHeader.Attributes["LastRevisedBy"].Value;
            if (nodeHeader.Attributes["LastRevisionTime"] != null)
                this.ReviseTime = DateTime.Parse(nodeHeader.Attributes["LastRevisionTime"].Value);
            if (nodeHeader.Attributes["Description"] != null)
                this.Description = nodeHeader.Attributes["Description"].Value;
            string chamberType = string.Empty;
            if (nodeHeader.Attributes["ChamberType"] != null)
                chamberType = nodeHeader.Attributes["ChamberType"].Value;

            if (!string.IsNullOrEmpty(chamberType) && chamberType != ChamberType)
            {
                LOG.Write($"{chamberType} is not accordance with {ChamberType}");
                return false;
            }
            if (nodeHeader.Attributes["Version"] != null)
                Version = nodeHeader.Attributes["Version"].Value;
            if (nodeHeader.Attributes["TableNumber"] != null)
                TableNumber = Convert.ToInt32(nodeHeader.Attributes["TableNumber"].Value);
            if (nodeHeader.Attributes["Permission"] != null)
                this.Permission = nodeHeader.Attributes["Permission"].Value;
            LoadHeaderExtend(nodeHeader);
            return true;
        }

        public virtual void LoadHeaderExtend(XmlNode nodeHeader)
        { 
        
        }

        public virtual void LoadSteps(XmlNodeList steps)
        {
            Steps.Clear();
            PopSettingSteps.Clear();
            StepTolerances.Clear();
            StepNos.Clear();
            int index = 1;
            foreach (XmlNode nodeStep in steps)
            {
                ParameterTable step = this.CreateStep(nodeStep);
                StepNos.Add(step.StepNo);
                //(rows[1] as StepParam).Value = index.ToString();

                //CreateStepTolerance(columns, popSettingColumns, nodeStep, out ObservableCollection<Param> step, out ObservableCollection<Param> warning,
                //    out ObservableCollection<Param> alarm, out Dictionary<string, ObservableCollection<Param>> popSettingStep
                //    );

                //StepTolerances.Add(step);
                //(step[1] as DoubleParam).Value = index.ToString();

                //StepTolerances.Add(warning);
                //(warning[1] as DoubleParam).Value = "Warn(%)";

                //StepTolerances.Add(alarm);
                //(alarm[1] as DoubleParam).Value = "Alarm(%)";

                Steps.Add(step);

                //foreach (string key in popSettingStep.Keys)
                //{
                //    if (!PopSettingSteps.ContainsKey(key))
                //    {
                //        PopSettingSteps.Add(key, new ObservableCollection<ObservableCollection<Param>>());
                //    }
                //    PopSettingSteps[key].Add(popSettingStep[key]);
                //}

                index++;
            }
            if (StepNos == null || StepNos.Count == 0)
            {
                StepNo = 1;
            }
            else
            {
                StepNo = StepNos.Max() + 1;
            }
        }

        private void LoadConfigs(ObservableCollection<Param> configDefine, XmlNode configNode)
        {
            ConfigItems.Clear();

            foreach (var param in configDefine)
            {
                if (param is DoubleParam param1)
                {
                    var config = new DoubleParam()
                    {
                        Name = param.Name,
                        Value = param1.Value,
                        DisplayName = param.DisplayName,
                        Minimun = param1.Minimun,
                        Maximun = param1.Maximun,
                        Resolution = param1.Resolution
                    };

                    if (configNode != null && configNode.Attributes[param1.Name] != null)
                        config.Value = configNode.Attributes[param1.Name].Value;

                    ConfigItems.Add(config);
                }

                if (param is StringParam paramString)
                {
                    var config = new StringParam()
                    {
                        Name = param.Name,
                        Value = paramString.Value,
                        DisplayName = param.DisplayName,
                    };

                    if (configNode != null && configNode.Attributes[paramString.Name] != null)
                        config.Value = configNode.Attributes[paramString.Name].Value;

                    ConfigItems.Add(config);
                }

            }
        }

        //public ObservableCollection<Param> CloneStep(ObservableCollection<EditorDataGridTemplateColumnBase> _columns, ObservableCollection<Param> _sourceParams)
        //{
        //    ObservableCollection<Param> targetParams = this.CreateStep(_columns);

        //    for (var index = 0; index < _sourceParams.Count; index++)
        //    {
        //        if (_sourceParams[index] is StringParam)
        //        {
        //            ((StringParam)targetParams[index]).Value = ((StringParam)_sourceParams[index]).Value;
        //        }
        //        else if (_sourceParams[index] is IntParam)
        //        {
        //            ((IntParam)targetParams[index]).Value = ((IntParam)_sourceParams[index]).Value;
        //        }
        //        else if (_sourceParams[index] is ComboxParam)
        //        {
        //            ((ComboxParam)targetParams[index]).Value = ((ComboxParam)_sourceParams[index]).Value;
        //        }
        //        else if (_sourceParams[index] is LoopComboxParam)
        //        {
        //            ((LoopComboxParam)targetParams[index]).Value = ((LoopComboxParam)_sourceParams[index]).Value;
        //        }
        //        else if (_sourceParams[index] is BoolParam)
        //        {
        //            ((BoolParam)targetParams[index]).Value = ((BoolParam)_sourceParams[index]).Value;
        //        }
        //        else if (_sourceParams[index] is IntParam)
        //        {
        //            ((IntParam)targetParams[index]).Value = ((IntParam)_sourceParams[index]).Value;
        //        }
        //        else if (_sourceParams[index] is DoubleParam)
        //        {
        //            ((DoubleParam)targetParams[index]).Value = ((DoubleParam)_sourceParams[index]).Value;
        //        }
        //        targetParams[index].Parent = targetParams;
        //    }

        //    return targetParams;
        //}
        private string GetConditionCheckXmlString(ParameterTable parameters)
        {
            StringBuilder conditionCheckStr = new StringBuilder();
            string externalSensor = "";

            conditionCheckStr.Append($"{externalSensor};");

            //conditionCheckStr.Append($"TempUpper:{parameters.TempUpper.ToString()};");
            //conditionCheckStr.Append($"TempLower:{parameters.TempLower.ToString()};");
            return conditionCheckStr.ToString();
        }



        public virtual string GetXmlString()
        {
            XmlElement nodeData = _doc.SelectSingleNode($"Aitex/TableParameterData") as XmlElement;

            nodeData.SetAttribute("CreatedBy", Creator);
            nodeData.SetAttribute("CreationTime", CreateTime.ToString("yyyy-MM-dd HH:mm:ss"));
            nodeData.SetAttribute("LastRevisedBy", Revisor);
            nodeData.SetAttribute("LastRevisionTime", ReviseTime.ToString("yyyy-MM-dd HH:mm:ss"));
            nodeData.SetAttribute("Description", Description);
            nodeData.SetAttribute("ParameterChamberType", ChamberType);
            nodeData.SetAttribute("Version", Version);
            nodeData.SetAttribute("TableNumber", TableNumber.ToString());
            nodeData.SetAttribute("Permission", Permission);
            nodeData.SetAttribute("ParameterLevel", Level);
            XmlNode nodeModule = _doc.SelectSingleNode($"Aitex/TableParameterData/Module[@Name='{_module}']");
            if (nodeModule == null)
            {
                nodeModule = _doc.CreateElement("Module");
                nodeData.AppendChild(nodeModule);
            }
            nodeModule.RemoveAll();
            (nodeModule as XmlElement).SetAttribute("Name", _module);
            int i = 0;
            foreach (ParameterTable parameters in Steps)
            {
                XmlElement nodeWarning = _doc.CreateElement("Warning");
                XmlElement nodeAlarm = _doc.CreateElement("Alarm");
                Dictionary<string, XmlElement> nodePop = new Dictionary<string, XmlElement>();
                foreach (string key in PopEnable.Keys)
                {
                    nodePop.Add(key, _doc.CreateElement(key));
                }

                XmlElement nodeStep = _doc.CreateElement("Step");

                if (ToleranceEnable)
                {
                    nodeStep.AppendChild(nodeWarning);
                    nodeStep.AppendChild(nodeAlarm);
                }
                nodeStep.SetAttribute("StepNo", parameters.StepNo.ToString());
                nodeStep.SetAttribute("Name", parameters.Name);
           //     nodeStep.SetAttribute("UseTemp", parameters.UseTemp);
                nodeModule.AppendChild(nodeStep);
                i++;
            }

            XmlElement nodeConfig = _doc.CreateElement("Config");
            foreach (Param parameter in ConfigItems)
            {
                if (parameter.Visible == System.Windows.Visibility.Visible)
                {
                    if (parameter is IntParam)
                        nodeConfig.SetAttribute(parameter.Name, ((IntParam)parameter).Value.ToString());
                    else if (parameter is DoubleParam)
                    {
                        string strValue = ((DoubleParam)parameter).Value;
                        bool succed = double.TryParse(strValue, out double dValue);

                        if (!succed)
                        {
                            MessageBox.Show($"The set value of {parameter.DisplayName} is {strValue}, not a valid value");
                            return null;
                        }

                        var config = ConfigItems.Where(m => m.Name == parameter.Name).FirstOrDefault();

                        if (config is DoubleParam param1)
                        {
                            if (param1.Minimun == 0 && param1.Maximun == 0)
                            {
                                //没有设定范围
                            }
                            else if (dValue > param1.Maximun || dValue < param1.Minimun)
                            {
                                MessageBox.Show($"The set value of {parameter.DisplayName} is {dValue}, out of the range {param1.Minimun}~{param1.Maximun}");
                                return null;
                            }
                        }

                        nodeConfig.SetAttribute(parameter.Name, ((DoubleParam)parameter).Value.ToString());
                    }
                    else if (parameter is StringParam)
                        nodeConfig.SetAttribute(parameter.Name, ((StringParam)parameter).Value.ToString());
                    else if (parameter is ComboxParam)
                        nodeConfig.SetAttribute(parameter.Name, ((ComboxParam)parameter).Value.ToString());
                    else if (parameter is LoopComboxParam)
                        nodeConfig.SetAttribute(parameter.Name, ((LoopComboxParam)parameter).Value.ToString());
                    else if (parameter is PositionParam)
                        nodeConfig.SetAttribute(parameter.Name, ((PositionParam)parameter).Value.ToString());
                    else if (parameter is BoolParam)
                        nodeConfig.SetAttribute(parameter.Name, ((BoolParam)parameter).Value.ToString());
                    else if (parameter is StepParam)
                        nodeConfig.SetAttribute(parameter.Name, ((StepParam)parameter).Value.ToString());
                    else if (parameter is MultipleSelectParam)
                    {
                        List<string> selected = new List<string>();
                        ((MultipleSelectParam)parameter).Options.Apply(
                             opt =>
                             {
                                 if (opt.IsChecked)
                                     selected.Add(opt.ControlName);
                             }
                                                    );
                        nodeConfig.SetAttribute(parameter.Name, string.Join(",", selected));
                    }
                }
            }
            nodeModule.AppendChild(nodeConfig);

            return _doc.OuterXml;
        }

        private void SetAttribute(ObservableCollection<Param> Parameters, XmlElement PopSettingStep)
        {
            if (Parameters != null)

                foreach (Param parameter1 in Parameters)
                {
                    if (parameter1.Visible != System.Windows.Visibility.Visible)
                        continue;

                    if (parameter1 is IntParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((IntParam)parameter1).Value.ToString());
                    else if (parameter1 is DoubleParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((DoubleParam)parameter1).Value.ToString());
                    else if (parameter1 is StringParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((StringParam)parameter1).Value.ToString());
                    else if (parameter1 is ComboxParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((ComboxParam)parameter1).Value.ToString());
                    else if (parameter1 is LoopComboxParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((LoopComboxParam)parameter1).Value.ToString());
                    else if (parameter1 is PositionParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((PositionParam)parameter1).Value.ToString());
                    else if (parameter1 is BoolParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((BoolParam)parameter1).Value.ToString());
                    else if (parameter1 is StepParam)
                        PopSettingStep.SetAttribute(parameter1.Name, ((StepParam)parameter1).Value.ToString());
                    else if (parameter1 is MultipleSelectParam)
                    {
                        List<string> selected1 = new List<string>();
                        ((MultipleSelectParam)parameter1).Options.Apply(
                            opt =>
                            {
                                if (opt.IsChecked)
                                    selected1.Add(opt.ControlName);
                            }
                            );
                        PopSettingStep.SetAttribute(parameter1.Name, string.Join(",", selected1));
                    }
                }
        }

        public string ToXmlString()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
            builder.Append(string.Format("<Aitex><TableRecipeData CreatedBy=\"{0}\" CreationTime=\"{1}\" LastRevisedBy=\"{2}\" LastRevisionTime=\"{3}\" Description=\"{4}\"  RecipeChamberType=\"{5}\" RecipeVersion=\"{6}\" TableNumber=\"{7}\">", this.Creator, this.CreateTime.ToString("yyyy-MM-dd HH:mm:ss"), this.Revisor, this.ReviseTime.ToString("yyyy-MM-dd HH:mm:ss"), this.Description, ChamberType, Version, TableNumber));

            foreach (ParameterTable parameters in Steps)
            {
                builder.Append("<Step ");
                builder.Append("Name=\"" + parameters.Name + "\" ");
                builder.Append("/>");
            }

            //builder.Append("<Config ");
            //foreach (Param parameter in ConfigItems)
            //{
            //    if (parameter.Visible == System.Windows.Visibility.Visible)
            //    {
            //        if (parameter is IntParam)
            //            builder.Append(parameter.Name + "=\"" + ((IntParam)parameter).Value + "\" ");
            //        else if (parameter is DoubleParam)
            //            builder.Append(parameter.Name + "=\"" + ((DoubleParam)parameter).Value + "\" ");
            //        else if (parameter is StringParam)
            //            builder.Append(parameter.Name + "=\"" + ((StringParam)parameter).Value + "\" ");
            //        else if (parameter is ComboxParam)
            //            builder.Append(parameter.Name + "=\"" + ((ComboxParam)parameter).Value + "\" ");
            //        else if (parameter is LoopComboxParam)
            //            builder.Append(parameter.Name + "=\"" + ((LoopComboxParam)parameter).Value + "\" ");
            //        else if (parameter is PositionParam)
            //            builder.Append(parameter.Name + "=\"" + ((PositionParam)parameter).Value + "\" ");
            //        else if (parameter is BoolParam)
            //            builder.Append(parameter.Name + "=\"" + ((BoolParam)parameter).Value + "\" ");
            //        else if (parameter is StepParam)
            //            builder.Append(parameter.Name + "=\"" + ((StepParam)parameter).Value + "\" ");
            //        else if (parameter is MultipleSelectParam)
            //        {
            //            List<string> selected = new List<string>();
            //            ((MultipleSelectParam)parameter).Options.Apply(
            //                opt =>
            //                {
            //                    if (opt.IsChecked)
            //                        selected.Add(opt.ControlName);
            //                }
            //                );
            //            builder.Append(parameter.Name + "=\"" + string.Join(",", selected) + "\" ");
            //        }
            //    }


            //}
            builder.Append("/>");

            builder.Append("</TableRecipeData></Aitex>");
            return builder.ToString();
        }

    }

    public class ParameterTable : PropertyChangedBase
    {
        public string Value { get; set; }

        private int _stepNo;
        public int StepNo
        {
            get => _stepNo; set
            {
                _stepNo = value;
                NotifyOfPropertyChange("StepNo");
            }
        }

        private string _name;
        public string Name
        {
            get => _name; set
            {
                _name = value;
                NotifyOfPropertyChange("Name");
            }
        }

        private string _useTemp;
        public string UseTemp
        {
            get => _useTemp;
            set
            {
                _useTemp = value;
                NotifyOfPropertyChange("UseTemp");
            }
        }

        private bool _isChecked;
        public bool IsChecked {
            get=> _isChecked;
            set
            {
                _isChecked = value;
                NotifyOfPropertyChange("IsChecked");
            } }
        public Visibility IsVisibility { get; set; } = Visibility.Visible;

       
        public ParameterTable() { }

        public ParameterTable Clone()//深拷贝
        {
            return this.MemberwiseClone() as ParameterTable;
        }
        public ParameterTable(ParameterDataBase recipeData)
        {
            if (recipeData.Steps.Count <= 0) return;
            SetCurrentRecipeStep(recipeData, recipeData.Steps[0]);
        }

        public ParameterTable(ParameterDataBase recipeData, int selectedStepNo)
        {
            ParameterTable step = recipeData.Steps.Where(x => x.StepNo == selectedStepNo).FirstOrDefault();
            SetCurrentRecipeStep(recipeData, step);
        }

        public virtual void SetCurrentRecipeStep(ParameterDataBase recipeData, ParameterTable step)
        {


        }

    }

    
}