using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using IwbZero.IwbBase;
using IwbZero.ToolCommon.StringModel;
using WeEngine;
using WeEngine.Enum;
using WeEngine.Packages;

namespace WePlatform.WeLib.Package.Dto
{
    public class ModelBase
    {
        public ModelBase()
        {
            Children = new List<ModelBase>();
            GuideInfos = new List<GuideModel>();
        }

        public PackageModel PackageModel { get; set; }
        public string Id { get; set; }
        public string No { get; set; }
        public string Name { get; set; }
        public string Path { get; set; }
        public string ParentPath { get; set; }
        //public string _guideNos;
        //public string GuideNos {
        //    get
        //    {
        //        return _guideNos.IsEmpty()
        //            ? string.Join(",", GuideInfos?.Select(a => a.Id) ?? new string[0])
        //            : _guideNos;
        //    }
        //    set => _guideNos = value;
        //}
        //public string GuideNames => string.Join(",", GuideInfos?.Select(a => a.Name) ?? new string[0]);
        public List<GuideModel> GuideInfos { get; set; }
        public string SceneCategory { get; set; }
        public string SceneCategoryName { get; set; }
        public string PreComponent { get; set; }
        public string RunningComponent { get; set; }
        public string PostComponent { get; set; }
        public string VariableStr { get; set; }
        public decimal Weights { get; set; }

        public List<ModelBase> Children { get; set; }
        protected Hashtable GetVariable( )
        {
            var table= new Hashtable();
            if (VariableStr.IsNotEmpty())
            {
                var varArr = VariableStr.StrToArray();
                foreach (var v in varArr)
                {
                    var variable = IwbRtVariable.Str2Variable(v);
                    table[variable.VarName] = variable;
                }
            }

            return table;
        }

        /// <summary>
        /// 转换Node
        /// </summary>
        /// <param name="node">空Node</param>
        /// <returns></returns>
        internal virtual NodeBase NodeFrom(NodeBase node)
        {
            node.Id = Id;
            node.InternalNo = No;
            node.Name = Name;
            node.EventComponentNode = new ComponentNode()
            {
                PreComponent = PreComponent,
                RunningComponent = RunningComponent,
                PostComponent = PostComponent
            };
            node.GuideInfos = GuideInfos?.Select(a => a.NodeFrom()).ToList() ?? new List<GuideNode>();
            node.Variables = GetVariable();
            node.Children = new List<NodeBase>();
            return node;
        }

        /// <summary>
        /// 转换Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal virtual void ModelFrom(NodeBase node)
        {
            Id = node.Id;
            No = node.InternalNo;
            Name = node.Name;
            Weights = node.Weights;
            Path = node.NodePath;
            ParentPath = node.Parent?.NodePath;
            VariableStr = Variable2Str(GetVariable());
            PreComponent = node.EventComponentNode?.PreComponent;
            RunningComponent = node.EventComponentNode?.RunningComponent;
            PostComponent = node.EventComponentNode?.PostComponent;
            GuideInfos = node.GuideInfos?.Select(a => new GuideModel().ModelFrom(a)).ToList() ?? new List<GuideModel>();
        }

        /// <summary>
        /// 变量转字符串
        /// </summary>
        /// <param name="variables"></param>
        /// <returns></returns>
        private string Variable2Str(Hashtable variables)
        {
            string str = "";
            if (variables != null && variables.Count > 0)
            {
                string vStr = "";
                foreach (DictionaryEntry entry in variables)
                {
                    var v = (IwbRtVariable)entry.Value;
                    vStr += (vStr == "" ? "" : ",") + IwbRtVariable.Variable2Str(v);
                }
            }

            return str;
        }
       

    }
    public class PackageModel: ModelBase
    {
        public PackageModel()
        {
            PackageModel = this;
        }

        public int RoundCount { get; set; }
        public string EngineType { 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<ComponentModel> Components { get; set; }

        #region ALL MODEL INFO

        public List<RoundModel> AllRoundModels => Children.Select(a => (RoundModel) a).ToList();
        public List<BlockModel> AllBlockModels
        {
            get
            {
                var list = new List<BlockModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllBlockModels);
                }
                return list;
            }
        }
        public List<SceneFlowModel> AllFlowModels
        {
            get
            {
                var list = new List<SceneFlowModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllFlowModels);
                }
                return list;
            }
        }
        public List<FlowModel> AllFlowNodeModels
        {
            get
            {
                var list = new List<FlowModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllFlowNodeModels);
                }
                return list;
            }
        }
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                foreach (var model in AllRoundModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

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


        #endregion

        public List<RoleModel> RoleInfos => PackageNodeFrom().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(PackageXmlInfo 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);
            return package;
        }

        /// <summary>
        /// 构建方案包Model
        /// </summary>
        /// <param name="xmlInfo"></param>
        /// <returns></returns>
        public PackageModel BuildPackageModelByXml(PackageXmlInfo 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,
                Parent = null,
            };
            package = (PackageNode)NodeFrom(package);
            return package;
        }

        #region XML
        public PackageXmlDto PackageFillXml()
        {
            var packageNode = PackageNodeFrom();
            var dto = new PackageXmlDto
            {
                PackageXml = packageNode.ToXmlString(),
                FlowXml = packageNode.Flows2Xml(),
                SceneXml = packageNode.Scenes2Xml(),
                BehaviorXml = packageNode.Behaviors2Xml(),
                GuideXml = packageNode.Guide2Xml(),
                EnvironResourceXml = packageNode.EnvironmentRender2Xml(),
                ComponentXml = GetComponentXml(Components),
                AllRoles = RoleInfos?.Count > 0
                    ? string.Join(",", RoleInfos.Select(a => a.ToString()).ToArray())
                    : ""
            };
            return dto;
        }

        private string GetComponentXml(List<ComponentModel> models)
        {
            string str = "";
            foreach (var m in models)
            {
                str += m.ToXmlString() + "\r\n";
            }
            if (str.IsNotEmpty())
            {
                str = $"<ComponentInfos>{str}</ComponentInfos>";
            }

            return str;

        }

        #endregion

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

        /// <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;
            if (node.HasChild)
            {
                foreach (var child in node.Children)
                {
                    var modal = new RoundModel() { PackageModel = PackageModel };
                    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; }

        #region ALL MODEL INFO

        public List<BlockModel> AllBlockModels => Children.Select(a => (BlockModel)a).ToList();
        public List<SceneFlowModel> AllFlowModels
        {
            get
            {
                var list = new List<SceneFlowModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllFlowModels);
                }
                return list;
            }
        }
        public List<FlowModel> AllFlowNodeModels
        {
            get
            {
                var list = new List<FlowModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllFlowNodeModels);
                }
                return list;
            }
        }
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                foreach (var model in AllBlockModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

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


        #endregion


        /// <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)
            {
                foreach (var child in Children)
                {
                    var childNode = new SceneFlowBlockNode(newNode);
                    newNode.Children.Add(child.NodeFrom(childNode));
                }
            }
            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;
            if (node.HasChild)
            {
                Children = new List<ModelBase>();
                foreach (var child in node.Children)
                {
                    var modal = new BlockModel() { PackageModel = PackageModel };
                    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; }

        #region ALL MODEL INFO

        public List<SceneFlowModel> AllFlowModels => Children.Select(a => (SceneFlowModel)a).ToList();
        public List<FlowModel> AllFlowNodeModels
        {
            get
            {
                var list = new List<FlowModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllFlowNodeModels);
                }
                return list;
            }
        }
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                foreach (var model in AllFlowModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }

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


        #endregion


        /// <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)
            {
                foreach (var child in Children)
                {
                    var childNode = new SceneFlowNode(newNode);
                    newNode.Children.Add(child.NodeFrom(childNode));
                }
            }
            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;
            if (node.HasChild)
            {
                foreach (var child in node.Children)
                {
                    var modal = new RoundModel() { PackageModel = PackageModel };
                    modal.ModelFrom(child);
                    Children.Add(modal);
                }
            }
        }

    }
    public class SceneFlowModel : ModelBase
    {
        public FlowModel ContentInfo { get; set; }

        #region ALL MODEL INFO

        public List<FlowModel> AllFlowNodeModels => Children.Select(a => (FlowModel)a).ToList();
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion


        /// <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)
            {
                foreach (var child in Children)
                {
                    var childNode = new FlowNode(newNode);
                    newNode.Children.Add(child.NodeFrom(childNode));
                }
            }
            return newNode;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            if (node.HasChild)
            {
                foreach (var child in node.Children)
                {
                    var modal = new FlowModel() { PackageModel = PackageModel };
                    modal.ModelFrom(child);
                    Children.Add(modal);
                }
            }
        }
    }
    public class FlowModel: ModelBase
    {
        public int Index { get; set; }
        public int FlowDepth { get; set; }
        public string SceneNos => string.Join(",", SceneInfos?.Select(a => a.Id) ?? new string[0]);
        public string SceneNames => string.Join(",", SceneInfos?.Select(a => a.Name) ?? new string[0]);
        public List<SceneModel> SceneInfos { get; set; }

        #region ALL MODEL INFO

        public List<FlowModel> AllFlowNodeModels => GetFlowModels(this);
        public List<SceneModel> AllSceneModels
        {
            get
            {
                var list = new List<SceneModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllSceneModels);
                }
                return list;
            }
        }
        public List<BehaviorModel> AllBehaviorModels
        {
            get
            {
                var list = new List<BehaviorModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllBehaviorModels);
                }
                return list;
            }
        }
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllFlowNodeModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion

        /// <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)
            {
                foreach (var child in Children)
                {
                    var childNode = new FlowNode(newNode);
                    newNode.Children.Add(child.NodeFrom(childNode));
                    

                }
            }
            if (SceneInfos?.Count > 0)
            {
                foreach (var sceneInfo in SceneInfos)
                {
                    var sceneNode = new SceneNode(newNode);
                    newNode.SceneInfos.Add((SceneNode)sceneInfo.NodeFrom(sceneNode));
                }
            }
            return newNode;
        }

        /// <summary>
        /// 转换Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (FlowNode)node;
            if (node.HasChild)
            {
                Children = new List<ModelBase>();
                foreach (var child in node.Children)
                {
                    var modal = new FlowModel() { PackageModel = PackageModel };
                    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() { PackageModel = PackageModel };
                    modal.ModelFrom(child);
                    Children.Add(modal);
                }
            }
        }

        private List<FlowModel> GetFlowModels(FlowModel model)
        {
            var list = new List<FlowModel>(){model};
            if (model.Children?.Count > 0)
            {
                foreach (var child in model.Children)
                {
                    list.AddRange(GetFlowModels((FlowModel)child));
                }
            }
            return list;
        }
    }
    public class SceneModel: ModelBase
    {
        public SceneModel()
        {
            EnvironResources = new List<EnvironResourceModel>();
        }

        public int SceneType { get; set; }
        public string SceneTag { get; set; }
        public string Description { get; set; }
        public string BehaviorNos { get; set; }
        //public string EnvironResourceNos { get; set; }
        public List<EnvironResourceModel> EnvironResources { get; set; }


        #region ALL MODEL INFO

        public List<BehaviorModel> AllBehaviorModels => Children.Select(a => (BehaviorModel) a).ToList();
        public List<GuideModel> AllGuideModels
        {
            get
            {
                var list = new List<GuideModel>();
                foreach (var model in AllBehaviorModels)
                {
                    list.AddRange(model.AllGuideModels);
                }
                return list;
            }
        }
        public List<EnvironResourceModel> AllEnvironResourceModels
        {
            get
            {
                var list = new List<EnvironResourceModel>();
                foreach (var model in AllBehaviorModels)
                {
                    list.AddRange(model.AllEnvironResourceModels);
                }
                return list;
            }
        }

        #endregion


        /// <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.EnvironResources = EnvironResources?.Select(a => a.NodeFrom()).ToList() ?? new List<EnvironResourceNode>();
            if (Children?.Count > 0)
            {
                foreach (var child in Children)
                {
                    var childNode = new BehaviorNode(newNode);
                    newNode.Children.Add(child.NodeFrom(childNode));
                }
            }
            return newNode;
        }

        /// <summary>
        /// 转换为Model
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        internal override void ModelFrom(NodeBase node)
        {
            base.ModelFrom(node);
            var node2 = (SceneNode)node;
            SceneTag = node2.SceneTag;
            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() { PackageModel = PackageModel };
                    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; }
        public List<RoleModel> BehaviorRoles { get; set; }
        //public string RoleNames { get; set; }
        public string RuleKeyword { get; set; }
        //public string EnvironResourceNos { get; set; }
        public string KnowledgeNos { get; set; }
        public List<EnvironResourceModel> EnvironResources { get; set; }

        #region ALL MODEL INFO

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

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

        #endregion

        /// <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.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;
            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() { PackageModel = PackageModel };
                    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 ComponentModel 
    {
        public string Id { get; set; }
        public string No { get; set; }
        public string Name { get; set; }
        public List<ComponentDataModel> Data { get; set; }
        public string ToXmlString()
        {
            var str = "";
            str += $"<ComponentInfo id=\"{Id}\">";
            str += $"<Id>{Id}</Id>\r\n";
            str += $"<Name>{Name}</Name>\r\n";
            var str1 = "";
            foreach (var cd in Data)
            {
                str1 += cd.ToXmlString();
            }
            str += str1.IsEmpty() ?"":$"<ComponentScript>{str1}</ComponentScript>\r\n" ;

            str += "</ComponentInfo>";
            return str;
        }

        public ComponentModel ModelFrom(IwbXmlNode xmlNode)
        {
            if (xmlNode == null)
            {
                return null;
            }
            Data=new List<ComponentDataModel>();
            Id = xmlNode.GetChildValue("Id");
            No = xmlNode.GetChildValue("No");
            Name = xmlNode.GetChildValue("Name");
            var scriptNodes= xmlNode.GetChildNode("ComponentScript")?.Nodes;
            if (scriptNodes?.Count > 0)
            {
                foreach (IwbXmlNode scriptNode in scriptNodes)
                {
                    var data= new ComponentDataModel().ModelFrom(scriptNode);
                    Data.Add(data);
                }
            }

            return this;
        }
        public List<ComponentModel> CreateByXml(string xml)
        {
            var node = IwbXmlNode.ParseGenericXml(xml);
            return CreateByXml(node);
        }
        public List<ComponentModel> CreateByXml(IwbXmlNode xmlNode)
        {
            var models = new List<ComponentModel>();
            var nodes = xmlNode?.Nodes;
            if (nodes?.Count > 0)
            {
                foreach (IwbXmlNode node in nodes)
                {
                    var model = new ComponentModel().ModelFrom(node);
                    if (model != null) models.Add(model);
                }
            }
            return models;
        }
    }
    public class ComponentDataModel 
    {
        public string Id { get; set; }
        public string No { get; set; }
        public string Name { get; set; }
        public string Path { get; set; }
        public string ParentPath { get; set; }
        public string CompType { get; set; }
        public VariableModel Variable { get; set; }
        public string Condition { get; set; }
        public List<ComponentDataModel> Yes { get; set; }
        public List<ComponentDataModel> Not { get; set; }
        public string WaitNodes { get; set; }
        public string Message { get; set; }

        public string ToXmlString()
        {
            string str = "", str1 = "";
            str += $"<{CompType} id=\"{Id}\">";
            if (Variable != null)
            {
                str1 += Variable.ToXmlString();
                str += str1.IsEmpty() ? "" : $"<Variable>{str1}</Variable>\r\n";

            }
            str += CompType.IsEmpty() ? "" : $"<CompType>{CompType}</CompType>\r\n";
            str += Name.IsEmpty() ? "" : $"<Name>{Name}</Name>\r\n";
            str += Path.IsEmpty() ? "" : $"<Name>{Path}</Name>\r\n";
            str += ParentPath.IsEmpty() ? "" : $"<Name>{ParentPath}</Name>\r\n";
            str += Condition.IsEmpty() ? "" : $"<Condition>{Condition.FormatCode2Xml()}</Condition>\r\n";
            str += WaitNodes.IsEmpty() ? "" : $"<WaitNodes>{WaitNodes}</WaitNodes>\r\n";
            str += Message.IsEmpty() ? "" : $"<Message>{Message}</Message>\r\n";
            str1 = "";
            if (Yes != null)
            {
                foreach (var cd in Yes)
                {
                    str1 += cd.ToXmlString();
                }
            }
               
            str += str1.IsEmpty() ? "" : $"<Yes>{str1}</Yes>\r\n";
            str1 = "";
            if (Not != null)
            {
                foreach (var cd in Not)
                {
                    str1 += cd.ToXmlString();
                }
            }
             
            str += str1.IsEmpty() ? "" : $"<No>{str1}</No>\r\n";
            str += $"</{CompType}>";
            return str;
        }

        public ComponentDataModel ModelFrom(IwbXmlNode xmlNode)
        {
            if (xmlNode == null)
                return null;
            Id = xmlNode.GetChildValue("Id");
            No = xmlNode.GetChildValue("No");
            Name = xmlNode.GetChildValue("Name");
            CompType = xmlNode.GetChildValue("CompType");
            Path = xmlNode.GetChildValue("Path");
            ParentPath = xmlNode.GetChildValue("ParentPath");
            Condition = xmlNode.GetChildValue("Condition");
            WaitNodes = xmlNode.GetChildValue("WaitNodes");
            Message = xmlNode.GetChildValue("Message");
            var variableNodes = xmlNode.GetChildNode("Variable")?.Nodes;
            if (variableNodes?.Count > 0)
            {
                Variable= new VariableModel();
                foreach (IwbXmlNode v in variableNodes)
                {
                    Variable.Name = v.GetChildValue("Name");
                    Variable.Type = v.GetChildValue("Type");
                    Variable.Value = v.GetChildValue("Value");
                    Variable.TargetPath = v.GetChildValue("TargetPath");
                    Variable.TargetName = v.GetChildValue("TargetName");
                }
            }
            Yes= new List<ComponentDataModel>();
            Not =new List<ComponentDataModel>();
            var yesNodes = xmlNode.GetChildNode("Yes")?.Nodes;
            if (yesNodes?.Count > 0)
            {
                foreach (IwbXmlNode y in yesNodes)
                {
                    var yes = new ComponentDataModel().ModelFrom(y);
                    if (yes != null) Yes.Add(yes);
                }
            }
            var noNodes = xmlNode.GetChildNode("Not")?.Nodes;
            if (noNodes?.Count > 0)
            {
                foreach (IwbXmlNode n in noNodes)
                {
                    var not = new ComponentDataModel().ModelFrom(n);
                    if (not != null) Not.Add(not);
                }
            }
            return this;
        }
    }
    public class VariableModel
    {
        public VariableModel()
        {
        }

        public VariableModel(string str)
        {
            var arr = str.StrToArray(":");
            Name = "";
            Type = "STRING";
            Value = "";

            if (arr.Length > 0)
            {
                Name = arr[0].Substring(2);
            }
            if (arr.Length > 1)
            {
                TargetPath = arr[1];
            }
            if (arr.Length > 2)
            {
                Value = arr[2];
            }
        }

        public string Name { get; set; }
        public string Type { get; set; }
        public string Value { get; set; }
        public string TargetPath { get; set; }
        public string TargetName { get; set; }
        public string ToXmlString()
        {
            string str = "";
           
            str += Name.IsEmpty() ? "" : $"<Name>{Name}</Name>\r\n";
            str += Type.IsEmpty() ? "" : $"<Type>{Type}</Type>\r\n";
            str += Value.IsEmpty() ? "" : $"<Value>{Value}</Value>\r\n";
            str += TargetPath.IsEmpty() ? "" : $"<TargetPath>{TargetPath}</TargetPath>\r\n";
            str += TargetName.IsEmpty() ? "" : $"<TargetName>{TargetName}</TargetName>\r\n";
          
            return str;
        }
    }

    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();
        }
    }
}