WEP_V2.1.3/SourceCode/We.Engine/WeEngine.Base/ModelInfo/PackageModel.cs

using IwbZero.Expr;
using IwbZero.IwbBase;
using IwbZero.ToolCommon.StringModel;

using Newtonsoft.Json;

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

using WeEngine.CommonDto.WeInfo;
using WeEngine.ComponentInfo;
using WeEngine.Enum;
using WeEngine.Packages;

namespace WeEngine.ModelInfo
{
    public class PackageModel : ModelBase
    {
        public PackageModel()
        {
            Children = new List<RoundModel>();
        }

        public int RoundCount { get; set; }
        public string EngineType { get; set; }

        /// <summary>
        /// 定性评估表达式
        /// </summary>
        public string EvalQualitativeExpression { get; set; }

        public string AssessRoles { get; set; }
        public string AssessRoleNos { get; set; }
        public bool AssessAuto { get; set; }
        public bool AutoNextRound { get; set; }
        public decimal RoundScore { get; set; }
        public List<EngineComponent> Components { get; set; }
        public List<RoundModel> _children;

        public new List<RoundModel> Children
        {
            get
            {
                if (PackageNode != null && PackageNode.HasChild && (_children == null || _children.Count == 0))
                {
                    _children = new List<RoundModel>();
                    foreach (var child in PackageNode.Children)
                    {
                        var modal = new RoundModel();
                        modal.ModelFrom(child);
                        _children.Add(modal);
                    }
                }
                return _children;
            }
            set => _children = value;
        }

        private PackageNode _package;

        [JsonIgnore]
        public PackageNode Package { get => _package ?? PackageNodeFrom(); set => _package = value; }

        #region ALL MODEL INFO

        [JsonIgnore]
        public List<RoundModel> AllRoundModels => Children ?? new List<RoundModel>();

        [JsonIgnore]
        public List<BlockModel> AllBlockModels
        {
            get
            {
                var list = new List<BlockModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllBlockModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<SceneFlowModel> AllFlowModels
        {
            get
            {
                var list = new List<SceneFlowModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllFlowModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<FlowModel> AllFlowNodeModels
        {
            get
            {
                var list = new List<FlowModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllFlowNodeModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                list.AddRange(GuideInfos ?? new List<GuideModel>());
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion ALL MODEL INFO

        public List<RoleModel> RoleInfos => Package?.AllRoleInfos
            .Select(a => new RoleModel(a.RoleNo, a.RoleName, a.RoleWeight, a.TotalWeight)).ToList();

        //public string AllRoleNames => RoleInfos?.Count > 0
        //    ? string.Join(",", RoleInfos.Select(a => a.ToString()).ToArray())
        //    : "";

        /// <summary>
        /// 构建方案包Node
        /// </summary>
        /// <param name="xmlInfo"></param>
        /// <returns></returns>
        public PackageNode BuildPackageNodeByXml(WePackageXmlDto xmlInfo)
        {
            var package = new PackageNode
            {
                AssessAuto = AssessAuto,
                AssessRoles = AssessRoles?.Split(',').ToList(),
                EngineType = EngineType,
                AutoNextRound = AutoNextRound,
                RoundScore = RoundScore,
                Parent = null,
                QueryFlowXmlFunc = id => PackageHelper.GetSceneFlowXmlFromXml(xmlInfo.FlowXml, id),
                QuerySceneXmlFunc = id => PackageHelper.GetSceneXmlFromXml(xmlInfo.SceneXml, id),
                QueryBehaviorXmlFunc = id => PackageHelper.GetBehaviorXmlFromXml(xmlInfo.BehaviorXml, id),
                QueryGuidesXmlFunc = ids => PackageHelper.GetGuidesXmlFromXml(xmlInfo.GuideXml, string.Join(",", ids)),
                QueryEnvironmentXmlFunc = id => PackageHelper.GetEnvironResourceXmlFromXml(xmlInfo.EnvironResourceXml, id),
            };
            var packageXmlNode = IwbXmlNode.ParseGenericXml(xmlInfo.PackageXml);
            package = (PackageNode)package.BuildNodeByXmlNode(packageXmlNode);
            Package = package;
            return package;
        }

        /// <summary>
        /// 构建方案包Model
        /// </summary>
        /// <param name="xmlInfo"></param>
        /// <returns></returns>
        public PackageModel BuildPackageModelByXml(WePackageXmlDto xmlInfo)
        {
            var packageNode = BuildPackageNodeByXml(xmlInfo);
            var packageModel = new PackageModel();
            packageModel.ModelFrom(packageNode);
            return packageModel;
        }

        /// <summary>
        /// Model转换为Node
        /// </summary>
        /// <returns></returns>
        public PackageNode PackageNodeFrom()
        {
            var package = new PackageNode
            {
                AssessAuto = AssessAuto,
                AssessRoles = AssessRoles?.Split(',').ToList(),
                EngineType = EngineType,
                AutoNextRound = AutoNextRound,
                RoundScore = RoundScore,
                EvalQualitativeExpression = EvalQualitativeExpression,
                Parent = null,
            };
            package = (PackageNode)NodeFrom(package);
            return package;
        }

        /// <summary>
        /// 方案包转换成 XML Dto
        /// </summary>
        /// <returns></returns>
        public WePackageXmlDto Package2Xml()
        {
            var packageNode = Package;
            var dto = new WePackageXmlDto
            {
                PackageXml = packageNode.ToXmlString(),
                FlowXml = packageNode.Flows2Xml(),
                SceneXml = packageNode.Scenes2Xml(),
                BehaviorXml = packageNode.Behaviors2Xml(),
                GuideXml = packageNode.Guide2Xml(),
                EnvironResourceXml = packageNode.EnvironmentRender2Xml(),
                ComponentXml = new EngineComponent().ConvertComponents2Xml(Components),
                AllRoles = RoleInfos?.Count > 0
                    ? string.Join(",", RoleInfos.Select(a => a.ToString()).ToArray())
                    : ""
            };
            return dto;
        }

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal override NodeBase NodeFrom(NodeBase node)
        {
            var node2 = (PackageNode)base.NodeFrom(node);
            node2.Parent = null;
            var children = new List<SceneRoundNode>();
            if (Children?.Count > 0)
            {
                foreach (var child in Children)
                {
                    var childNode = new SceneRoundNode(node2);
                    children.Add((SceneRoundNode)child.NodeFrom(childNode));
                }
            }

            node2.Children = children;
            return node2;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (PackageNode)node;
            AssessAuto = node2.AssessAuto;
            AssessRoles = string.Join(",", node2.AssessRoles);
            EngineType = node2.EngineType;
            AutoNextRound = node2.AutoNextRound;
            RoundScore = node2.RoundScore;
            EvalQualitativeExpression = node2.EvalQualitativeExpression;

            PackageNode = node2;
            //if (node.HasChild)
            //{
            //    Children= new List<RoundModel>();
            //    foreach (var child in node.Children)
            //    {
            //        var modal = new RoundModel() ;
            //        modal.ModelFrom(child);
            //        Children.Add(modal);
            //    }
            //}
        }
    }

    public class RoundModel : ModelBase
    {
        public int RoundIndex { get; set; }
        public int BlockIndex { get; set; }
        public decimal RoundFullScore { get; set; }
        public int ControlRate { get; set; }
        public int SceneCount { get; set; }
        public List<BlockModel> _children;

        public new List<BlockModel> Children
        {
            get
            {
                if (PackageNode != null && PackageNode.HasChild && (_children == null || _children.Count == 0))
                {
                    _children = new List<BlockModel>();
                    foreach (var child in PackageNode.Children)
                    {
                        var modal = new BlockModel();
                        modal.ModelFrom(child);
                        _children.Add(modal);
                    }
                }
                return _children;
            }
            set => _children = value;
        }

        #region ALL MODEL INFO

        [JsonIgnore]
        public List<BlockModel> AllBlockModels => Children ?? new List<BlockModel>();

        [JsonIgnore]
        public List<SceneFlowModel> AllFlowModels
        {
            get
            {
                var list = new List<SceneFlowModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllFlowModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<FlowModel> AllFlowNodeModels
        {
            get
            {
                var list = new List<FlowModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllFlowNodeModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                list.AddRange(GuideInfos ?? new List<GuideModel>());
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion ALL MODEL INFO

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal override NodeBase NodeFrom(NodeBase node)
        {
            var newNode = (SceneRoundNode)base.NodeFrom(node);
            newNode.RoundIndex = RoundIndex;
            newNode.RoundFullScore = RoundFullScore;
            newNode.ControlRate = ControlRate;
            newNode.SceneCount = SceneCount;
            if (Children?.Count > 0)
            {
                var list = new List<SceneFlowBlockNode>();
                foreach (var child in Children)
                {
                    var childNode = new SceneFlowBlockNode(newNode);
                    list.Add((SceneFlowBlockNode)child.NodeFrom(childNode));
                }
                newNode.Children = list;
            }
            return newNode;
        }

        /// <summary>
        /// 转换Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (SceneRoundNode)node;
            RoundIndex = node2.RoundIndex;
            RoundFullScore = node2.RoundFullScore;
            ControlRate = node2.ControlRate;
            SceneCount = node2.SceneCount;
            PackageNode = node2;
            //if (node.HasChild)
            //{
            //    Children = new List<BlockModel>();
            //    foreach (var child in node.Children)
            //    {
            //        var modal = new BlockModel();
            //        modal.ModelFrom(child);
            //        Children.Add(modal);
            //    }
            //}
        }
    }

    public class BlockModel : ModelBase
    {
        public int BlockType { get; set; }
        public string FlowNos { get; set; }
        public string FlowNames { get; set; }
        public List<SceneFlowModel> _children;

        public new List<SceneFlowModel> Children
        {
            get
            {
                if (PackageNode != null && PackageNode.HasChild && (_children == null || _children.Count == 0))
                {
                    _children = new List<SceneFlowModel>();
                    foreach (var child in PackageNode.Children)
                    {
                        var modal = new SceneFlowModel();
                        modal.ModelFrom(child);
                        _children.Add(modal);
                    }
                }
                return _children;
            }
            set => _children = value;
        }

        #region ALL MODEL INFO

        [JsonIgnore]
        public List<SceneFlowModel> AllFlowModels => Children ?? new List<SceneFlowModel>();

        [JsonIgnore]
        public List<FlowModel> AllFlowNodeModels
        {
            get
            {
                var list = new List<FlowModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllFlowNodeModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                list.AddRange(GuideInfos ?? new List<GuideModel>());
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion ALL MODEL INFO

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal override NodeBase NodeFrom(NodeBase node)
        {
            var newNode = (SceneFlowBlockNode)base.NodeFrom(node);
            newNode.BlockType = (SceneFlowBlockType)BlockType;
            if (Children?.Count > 0)
            {
                var list = new List<SceneFlowNode>();
                foreach (var child in Children)
                {
                    var childNode = new SceneFlowNode(newNode);
                    list.Add((SceneFlowNode)child.NodeFrom(childNode));
                }
                newNode.Children = list;
            }
            return newNode;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (SceneFlowBlockNode)node;
            BlockType = (int)node2.BlockType;
            PackageNode = node2;

            //if (node.HasChild)
            //{
            //    Children = new List<SceneFlowModel>();
            //    foreach (var child in node.Children)
            //    {
            //        var modal = new SceneFlowModel();
            //        modal.ModelFrom(child);
            //        Children.Add(modal);
            //    }
            //}
        }
    }

    public class SceneFlowModel : ModelBase
    {
        public FlowModel ContentInfo { get; set; }
        public List<FlowModel> _children;

        public new List<FlowModel> Children
        {
            get
            {
                if (PackageNode != null && PackageNode.HasChild && (_children == null || _children.Count == 0))
                {
                    _children = new List<FlowModel>();
                    foreach (var child in PackageNode.Children)
                    {
                        var modal = new FlowModel();
                        modal.ModelFrom(child);
                        _children.Add(modal);
                    }
                }
                return _children;
            }
            set => _children = value;
        }

        #region ALL MODEL INFO

        [JsonIgnore]
        public List<FlowModel> AllFlowNodeModels
        {
            get
            {
                var list = new List<FlowModel>();
                foreach (var child in Children)
                {
                    list.AddRange(GetFlowModels(child));
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                list.AddRange(GuideInfos ?? new List<GuideModel>());
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion ALL MODEL INFO

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal override NodeBase NodeFrom(NodeBase node)
        {
            var newNode = (SceneFlowNode)base.NodeFrom(node);
            if (Children?.Count > 0)
            {
                var list = new List<FlowNode>();
                foreach (var child in Children)
                {
                    var childNode = new FlowNode(newNode);
                    list.Add((FlowNode)child.NodeFrom(childNode));
                }
                newNode.Children = list;
            }
            return newNode;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (SceneFlowNode)node;
            PackageNode = node2;
            //if (node.HasChild)
            //{
            //    Children = new List<FlowModel>();
            //    foreach (var child in node.Children)
            //    {
            //        var modal = new FlowModel();
            //        modal.ModelFrom(child);
            //        Children.Add(modal);
            //    }
            //}
        }

        private List<FlowModel> GetFlowModels(FlowModel model)
        {
            var list = new List<FlowModel>();
            if (model == null)
            {
                return list;
            }
            list.Add(model);
            if (model.Children?.Count > 0)
            {
                foreach (var child in model.Children)
                {
                    var children = GetFlowModels(child);
                    list.AddRange(children);
                }
            }
            return list;
        }
    }

    public class FlowModel : ModelBase
    {
        public int Index { get; set; }
        public int FlowDepth { get; set; }

        [JsonIgnore]
        public string _sceneNos;

        public string SceneNos
        {
            get
            {
                return _sceneNos ??
                       string.Join(",", Children?.Select(a => a.Id).ToArray() ?? Array.Empty<string>());
            }
            set => _sceneNos = value;
        }

        public string SceneNames => string.Join(",", SceneInfos?.Select(a => a.Name) ?? Array.Empty<string>());

        public List<FlowModel> _children;

        public new List<FlowModel> Children
        {
            get
            {
                if (PackageNode != null && PackageNode.HasChild && (_children == null || _children.Count == 0))
                {
                    _children = new List<FlowModel>();
                    foreach (var child in PackageNode.Children)
                    {
                        var modal = new FlowModel();
                        modal.ModelFrom(child);
                        _children.Add(modal);
                    }
                }
                return _children;
            }
            set => _children = value;
        }

        public List<SceneModel> _sceneInfos;

        public List<SceneModel> SceneInfos
        {
            get
            {
                if (PackageNode != null &&  (_sceneInfos == null || _sceneInfos.Count == 0))
                {
                    _sceneInfos = new List<SceneModel>();
                    if (PackageNode != null)
                    {
                        var node = (FlowNode)PackageNode;
                        foreach (var child in node.SceneInfos)
                        {
                            var modal = new SceneModel();
                            modal.ModelFrom(child);
                            _sceneInfos.Add(modal);
                        }
                    }
                }
                return _sceneInfos;
            }
            set => _sceneInfos = value;
        }

        #region ALL MODEL INFO

        [JsonIgnore]
        public List<SceneModel> AllSceneModels => SceneInfos ?? new List<SceneModel>();

        [JsonIgnore]
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllSceneModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                list.AddRange(GuideInfos ?? new List<GuideModel>());
                foreach (var model in AllSceneModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllSceneModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion ALL MODEL INFO

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal override NodeBase NodeFrom(NodeBase node)
        {
            var newNode = (FlowNode)base.NodeFrom(node);
            if (Children?.Count > 0)
            {
                var list = new List<FlowNode>();
                foreach (var child in Children)
                {
                    var childNode = new FlowNode(newNode);
                    list.Add((FlowNode)child.NodeFrom(childNode));
                }
                newNode.Children = list;
            }
            if (SceneInfos?.Count > 0)
            {
                var list = new List<SceneNode>();
                foreach (var child in SceneInfos)
                {
                    var childNode = new SceneNode(newNode);
                    list.Add((SceneNode)child.NodeFrom(childNode));
                }
                newNode.SceneInfos = list;
            }
            return newNode;
        }

        /// <summary>
        /// 转换Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (FlowNode)node;
            PackageNode = node2;
            //if (node.HasChild)
            //{
            //    Children = new List<FlowModel>();
            //    foreach (var child in node.Children)
            //    {
            //        var modal = new FlowModel();
            //        modal.ModelFrom(child);
            //        Children.Add(modal);
            //    }
            //}
            //if (node2.SceneInfos?.Count > 0)
            //{
            //    SceneInfos = new List<SceneModel>();
            //    foreach (var child in node2.SceneInfos)
            //    {
            //        var modal = new SceneModel();
            //        modal.ModelFrom(child);
            //        SceneInfos.Add(modal);
            //    }
            //}
        }
    }

    public class SceneModel : ModelBase
    {
        public SceneModel()
        {
            Children = new List<BehaviorModel>();
            EnvironResources = new List<EnvironResourceModel>();
        }

        public int SceneType { get; set; }
        public string SceneTag { get; set; }
        public string _description { get; set; }

        public string Description
        {
            get
            {
                var desc = _description ?? "";
                if (Variables != null && _description.IsNotEmpty())
                {
                    if (desc.IndexOf(IwbVariableType.Local, StringComparison.Ordinal) >= 0)
                    {
                        var reg = new Regex("@[0-9,a-z,A-Z]*");
                        desc = reg.Replace(desc, match => match.ToString().ToUpper());
                        desc = EvalExpr.TransVariable(desc, Variables);
                    }
                    //foreach (DictionaryEntry entry in Variables)
                    //{
                    //    var variable = (IwbRtVariable)entry.Value;
                    //    desc = desc.Replace(variable.VarName.ToUpper(), variable.GetStringValue());
                    //}

                    return desc;
                }
                return desc;
            }
        }

        [JsonIgnore]
        public string _behaviorNos;

        public string BehaviorNos
        {
            get
            {
                return _behaviorNos ??
                       string.Join(",", Children?.Select(a => a.Id).ToArray() ?? Array.Empty<string>());
            }
            set => _behaviorNos = value;
        }

        [JsonIgnore]
        private string _environResourceNos;

        public string EnvironResourceNos
        {
            get
            {
                return _environResourceNos ??
                       string.Join(",", EnvironResources?.Select(a => a.Id).ToArray() ?? Array.Empty<string>());
            }
            set => _environResourceNos = value;
        }

        private List<EnvironResourceModel> _environResources;

        [JsonIgnore]
        public List<EnvironResourceModel> EnvironResources
        {
            get
            {
                if (_environResources == null)
                {
                    var node = (SceneNode)PackageNode;
                    _environResources = node?.EnvironResources?.Select(a => new EnvironResourceModel().ModelFrom(a)).ToList() ??
                                       new List<EnvironResourceModel>();
                }
                return _environResources;
            }
            set => _environResources = value;
        }

        [JsonIgnore]
        public Hashtable _variables;

        [JsonIgnore]
        public Hashtable Variables
        {
            get => _variables != null && _variables.Count > 0 ? _variables : GetVariable();
            set => _variables = value;
        }

        [JsonIgnore]
        public List<BehaviorModel> _children;

        public new List<BehaviorModel> Children
        {
            get
            {
                if (PackageNode != null && PackageNode.HasChild && (_children == null || _children.Count == 0))
                {
                    _children = new List<BehaviorModel>();
                    foreach (var child in PackageNode.Children)
                    {
                        var modal = new BehaviorModel();
                        modal.ModelFrom(child);
                        _children.Add(modal);
                    }
                }
                return _children;
            }
            set => _children = value;
        }

        #region ALL MODEL INFO

        [JsonIgnore]
        public List<BehaviorModel> AllBehaviorModels => Children;

        [JsonIgnore]
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                list.AddRange(GuideInfos ?? new List<GuideModel>());
                foreach (var model in AllBehaviorModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

        [JsonIgnore]
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                list.AddRange(EnvironResources ?? new List<EnvironResourceModel>());
                foreach (var model in AllBehaviorModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion ALL MODEL INFO

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal override NodeBase NodeFrom(NodeBase node)
        {
            var newNode = (SceneNode)base.NodeFrom(node);
            newNode.SceneTag = SceneTag;
            newNode.Description = _description;
            newNode.SceneType = (SceneType)SceneType;
            newNode.EnvironResources = EnvironResources?.Select(a => a.NodeFrom()).ToList() ?? new List<EnvironResourceNode>();
            if (Children?.Count > 0)
            {
                var list = new List<BehaviorNode>();
                foreach (var child in Children)
                {
                    var childNode = new BehaviorNode(newNode);
                    list.Add((BehaviorNode)child.NodeFrom(childNode));
                }
                newNode.Children = list;
            }
            return newNode;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (SceneNode)node;
            PackageNode = node2;
            SceneTag = node2.SceneTag;
            SceneType = (int)node2.SceneType;
            _description = node2.Description;

            //EnvironResources = node2.EnvironResources?.Select(a => new EnvironResourceModel().ModelFrom(a)).ToList() ?? new List<EnvironResourceModel>();
            //if (node.HasChild)
            //{
            //    foreach (var child in node.Children)
            //    {
            //        var modal = new BehaviorModel();
            //        modal.ModelFrom(child);
            //        Children.Add(modal);
            //    }
            //}
        }
    }

    public class BehaviorModel : ModelBase
    {
        public BehaviorModel()
        {
            EnvironResources = new List<EnvironResourceModel>();
        }

        public string BehaviorTag { get; set; }
        public string Description { get; set; }
        public int BehaviorScoreType { get; set; }
        public int RoleLogicType { get; set; }
        private List<RoleModel> _behaviorRoles { get; set; }

        public List<RoleModel> BehaviorRoles
        {
            get
            {
                if (_behaviorRoles == null)
                {
                    var node = (BehaviorNode)PackageNode;
                    _behaviorRoles = node?.BehaviorRoles?.Count > 0
                        ? node.BehaviorRoles.Select(a => new RoleModel(a.RoleNo, a.RoleName, a.RoleWeight, a.TotalWeight)).ToList()
                        : new List<RoleModel>();
                }
                return _behaviorRoles;
            }
            set => _behaviorRoles = value;
        }

        public string RoleNames => string.Join(",", BehaviorRoles?.Select(a => a.RoleName).ToList() ?? new List<string>());
        public string RuleKeyword { get; set; }
        public string KnowledgeNos { get; set; }

        [JsonIgnore]
        private string _environResourceNos;

        public string EnvironResourceNos
        {
            get
            {
                return _environResourceNos ??
                       string.Join(",", EnvironResources?.Select(a => a.Id).ToArray() ?? new string[0]);
            }
            set => _environResourceNos = value;
        }

        private List<EnvironResourceModel> _environResources;

        [JsonIgnore]
        public List<EnvironResourceModel> EnvironResources
        {
            get
            {
                if (_environResources == null)
                {
                    var node = (BehaviorNode)PackageNode;
                    _environResources = node?.EnvironResources?.Select(a => new EnvironResourceModel().ModelFrom(a)).ToList() ??
                                        new List<EnvironResourceModel>();
                }
                return _environResources;
            }
            set => _environResources = value;
        }

        #region ALL MODEL INFO

        [JsonIgnore]
        public List<GuideModel> AllGuideModels => GuideInfos ?? new List<GuideModel>();

        [JsonIgnore]
        public List<EnvironResourceModel> AllEnvironResourceModels =>
            EnvironResources ?? new List<EnvironResourceModel>();

        #endregion ALL MODEL INFO

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal override NodeBase NodeFrom(NodeBase node)
        {
            var newNode = (BehaviorNode)base.NodeFrom(node);
            newNode.BehaviorTag = BehaviorTag;
            newNode.BehaviorRoleLogic = (BehaviorRoleLogicType)RoleLogicType;
            newNode.BehaviorScoreType = (BehaviorScoreType)BehaviorScoreType;
            newNode.BehaviorRoles = BehaviorRoles?.Count > 0
                ? BehaviorRoles.Select(a => new RoleNode(a.RoleNo, a.RoleName)).ToList()
                : new List<RoleNode>();
            newNode.EnvironResources = new List<EnvironResourceNode>();
            newNode.Description = Description;
            newNode.BuildKeywordNodes(RuleKeyword);
            newNode.EnvironResources = EnvironResources?.Select(a => a.NodeFrom()).ToList() ?? new List<EnvironResourceNode>();
            return newNode;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (BehaviorNode)node;
            BehaviorTag = node2.BehaviorTag;
            RoleLogicType = (int)node2.BehaviorRoleLogic;
            BehaviorScoreType = (int)node2.BehaviorScoreType;
            //BehaviorRoles = node2.BehaviorRoles?.Count > 0
            //    ? node2.BehaviorRoles.Select(a => new RoleModel(a.RoleNo, a.RoleName, a.RoleWeight, a.TotalWeight)).ToList()
            //    : new List<RoleModel>();
            Description = node2.Description;
            RuleKeyword = node2.Keywords;
            //EnvironResources = node2.EnvironResources?.Select(a => new EnvironResourceModel().ModelFrom(a)).ToList() ?? new List<EnvironResourceModel>();

            //if (node.HasChild)
            //{
            //    foreach (var child in node.Children)
            //    {
            //        var modal = new BehaviorModel() ;
            //        modal.ModelFrom(child);
            //        Children.Add(modal);
            //    }
            //}
        }
    }

    public class GuideModel
    {
        public string Id { get; set; }

        /// <summary>
        /// 提示名称
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 提示详情
        /// </summary>
        public string Description { get; set; }

        /// <summary>
        /// 提示类型
        /// </summary>
        public int GuideType { get; set; }

        public GuideNode NodeFrom()
        {
            var node = new GuideNode
            {
                Id = Id,
                Name = Name,
                GuideType = GuideType,
                Description = Description,
            };
            return node;
        }

        public GuideModel ModelFrom(GuideNode node)
        {
            if (node == null)
            {
                return null;
            }
            Id = node.Id;
            Name = node.Name;
            GuideType = node.GuideType;
            Description = node.Description;
            return this;
        }
    }

    public class EnvironResourceModel
    {
        public string Id { get; set; }

        /// <summary>
        /// 资源名称
        /// </summary>
        public string ResourceName { get; set; }

        /// <summary>
        /// 资源类型
        /// </summary>
        public int ResourceType { get; set; }

        /// <summary>
        /// 资源路径
        /// </summary>
        public string ResourcePath { get; set; }

        /// <summary>
        /// 资源描述
        /// </summary>
        public string Description { get; set; }

        public string MessageCode { get; set; }

        public EnvironResourceNode NodeFrom()
        {
            var node = new EnvironResourceNode
            {
                Id = Id,
                ResourceName = ResourceName,
                ResourceType = ResourceType,
                ResourcePath = ResourcePath,
                Description = Description,
                MessageCode = MessageCode
            };
            return node;
        }

        public EnvironResourceModel ModelFrom(EnvironResourceNode node)
        {
            if (node == null)
            {
                return null;
            }
            Id = node.Id;
            ResourceName = node.ResourceName;
            ResourceType = node.ResourceType;
            ResourcePath = node.ResourcePath;
            MessageCode = node.MessageCode;
            Description = node.Description;
            return this;
        }
    }

    public class RoleModel
    {
        public RoleModel()
        {
        }

        public RoleModel(string roleNo, string roleName)
        {
            RoleNo = roleNo;
            RoleName = roleName;
            RoleWeight = 1;
            TotalWeight = 1;
        }

        public RoleModel(string roleNo, string roleName, decimal roleWeight, decimal totalWeight)
        {
            RoleNo = roleNo;
            RoleName = roleName;
            RoleWeight = roleWeight;
            TotalWeight = totalWeight;
        }

        public string RoleNo { get; set; }
        public string RoleName { get; set; }
        public decimal RoleWeight { get; }
        public decimal TotalWeight { get; }
        public decimal RolePer => Math.Round(TotalWeight == 0 ? 0 : RoleWeight * 100 / TotalWeight, 2);

        public static RoleModel ModelFrom(string roles)
        {
            var node = new RoleNode();
            var arr = roles.Split(':');
            node.RoleNo = arr[0];
            if (arr.Length > 1)
            {
                node.RoleName = arr[1];
            }
            if (arr.Length > 2)
            {
                node.SetWeight(int.TryParse(arr[2], out var w) ? w : 0);
            }
            if (arr.Length > 3)
            {
                node.SetTotalWeight(int.TryParse(arr[3], out var w) ? w : 0);
            }
            return new RoleModel(node.RoleNo, node.RoleName, node.RoleWeight, node.TotalWeight);
        }

        public override string ToString()
        {
            return new RoleNode(RoleNo, RoleName, RoleWeight, TotalWeight).ToString();
        }
    }
}