/// <summary>
/// BaseNode.cs
/// 节点基类
/// </summary>
public class BaseNode : ScriptableObject
{
    /// <summary>
    /// 唯一ID
    /// </summary>
    [Header("唯一ID")]
    public string GUID;

    /// <summary>
    /// 位置
    /// </summary>
    [Header("位置")]
    [HideInInspector]
    public Rect Position;

    /// <summary>
    /// 节点描述
    /// </summary>
    [Header("节点描述")]
    [HideInInspector]
    public string Des = "节点描述";

    /// <summary>
    /// 是否是根节点
    /// </summary>
    public virtual bool EntryPoint
    {
        get
        {
            return false;
        }
    }

    /// <summary>
    /// 节点类型(子类重写自定义节点类型)
    /// </summary>
    public virtual NodeType NodeType
    {
        get
        {
            return NodeType.Composition;
        }
    }

    /// <summary>
    /// 节点状态
    /// </summary>
    public NodeState NodeState
    {
        get;
        protected set;
    }
    
    ******
}

/// <summary>
/// NodeType.cs
/// 节点类型
/// </summary>
public enum NodeType
{
    Composition,               // 行为树组合节点
    Decoration,                // 行为树装饰节点
    Condition,                 // 行为树条件节点
    Action,                    // 行为树行为节点
}

/// <summary>
/// UIBTGraphEditorWindow.cs
/// 行为树图窗口类
/// </summary>
public class UIBTGraphEditorWindow : EditorWindow
{
    ******    
    
    /// <summary>
    /// 可用的节点类型列表
    /// </summary>
    private List<NodeType> mAvailableNodeTypeList;

    /// <summary>
    /// 可用节点类型Map
    /// </summary>
    private Dictionary<NodeType, NodeType> mAvailableNodeTypeMap;

    /// <summary>
    /// 节点类型和对应节点类型信息Map
    /// </summary>
    private Dictionary<NodeType, List<Type>> mNodeTypeTypeMap;
    
    ******
    
   /// <summary>
    /// 初始化节点数据
    /// </summary>
    private void InitNodeDatas()
    {
        mAvailableNodeTypeList = GetInitAvalibleNodeTypeList();
        InitNodeTypeDatas();
    }

    /// <summary>
    /// 获取初始化可用节点类型列表
    /// </summary>
    /// <returns></returns>
    protected virtual List<NodeType> GetInitAvalibleNodeTypeList()
    {
        return new List<NodeType>()
        {
            NodeType.Dialogue,
            NodeType.Composition,
            NodeType.Decoration,
            NodeType.Condition,
            NodeType.Action,
        };
    }

    /// <summary>
    /// 初始化节点类型数据
    /// </summary>
    private void InitNodeTypeDatas()
    {
        InitAvalibleNodeTypeMapData();
        InitNodeTypeTypeListData();
    }

    /// <summary>
    /// 初始化节点类型Map数据
    /// </summary>
    private void InitAvalibleNodeTypeMapData()
    {
        mAvailableNodeTypeMap = new Dictionary<NodeType, NodeType>();
        foreach(var availableNodeType in mAvailableNodeTypeList)
        {
            if(!mAvailableNodeTypeMap.ContainsKey(availableNodeType))
            {
                mAvailableNodeTypeMap.Add(availableNodeType, availableNodeType);
            }
        }
    }

    /// <summary>
    /// 初始化节点类型类型信息列表数据
    /// </summary>
    private void InitNodeTypeTypeListData()
    {
        mNodeTypeTypeMap = new Dictionary<NodeType, List<Type>>();
        foreach (var availableNodeType in mAvailableNodeTypeList)
        {
            if (!mNodeTypeTypeMap.ContainsKey(availableNodeType))
            {
                mNodeTypeTypeMap.Add(availableNodeType, new List<Type>());
            }
        }
        var allNodeTypes = CommonGraphConst.BaseNodeAssembly.GetTypes().Where(
            nodeType => (CommonGraphConst.BaseNodeType.IsAssignableFrom(nodeType) && !nodeType.IsAbstract && nodeType != CommonGraphConst.BaseNodeType));
        foreach(var type in allNodeTypes)
        {
            var nodeInstance = Activator.CreateInstance(type) as BaseNode;
            if(IsAvailableNodeType(nodeInstance.NodeType))
            {
                List<Type> typeList;
                if(mNodeTypeTypeMap.TryGetValue(nodeInstance.NodeType, out typeList))
                {
                    typeList.Add(type);
                }
            }
        }
    }
    
    /// <summary>
    /// 创建所有节点类型的UI
    /// </summary>
    private void CreateAllNodeTypeUI()
    {
        foreach(var availableNodeType in mAvailableNodeTypeList)
        {
            var nodeFoldOut = new FoldOut();
            var nodeTypeTitle = CommonGraphUtilities.GetNodeTypeTitle(availableNodeType);
            nodeFoldOut.name = nodeTypeTitle;
            nodeFoldOut.viewDataKey = CommonGraphUtilities.GetNodeTypeFoldOutViewDataKeyName(availableNodeType);
            nodeFoldOut.text = nodeTypeTitle;
            nodeFoldOut.AddToClassList("unity-box");
            var typeList = GetTypeListByNodeType(availableNodeType);
            var nodeListView = new ListView(typeList, 20, OnMakeNodeItem, (NodeItemUserData, index) =>
                                            {
                                                OnBindNodeItem(item, index, availableNodeType);
                                            });
            nodeFoldOut.Add(nodeListView);
            // 注册节点FoldOut值变化回调
            nodeFoldOut.ReigsterValueChangedCallback(OnNodeFoldOutValueChange);
            var nodeVerticalContainer = rootVisualElement.Q<VisualElement>(CommonGraphElementNames.NodeVerticalContainerName);
            nodeVerticalContainer.Add(nodeFoldOut);
        }
    }

    
    ******
}

/// <summary>
/// UIBTGraphEditorWindow.cs
/// 通用节点编辑器窗口
/// </summary>
public class UIBTGraphEditorWindow : EditorWindow
{
   ******

    /// <summary>
    /// 创建节点编辑器GraphView
    /// </summary>
    protected virtual void CreateGraphView()
    {
        ClearGraphView();
        var middleGraphViewContainer = rootVisualElement.Q<VisualElement>(BTGraphElementNames.MiddleGraphViewContainerName);
        mGraphView = GetNewGraphView();
        mGraphView.StretchToParentSize();
        middleGraphViewContainer.Add(mGraphView);
    }

    /// <summary>
    /// 创建新的GraphView
    /// </summary>
    /// <returns></returns>
    protected BehaviourTreeGraphView GetNewGraphView()
    {
        return new BehaviourTreeGraphView(mAvailableNodeTypeList, this.OnSelectedNodeChange);
    }
        
    ******
}

/// <summary>
/// BehaviourTreeGraphView.cs
/// 行为树GraphView
/// </summary>
public class BehaviourTreeGraphView : GraphView
{
   ******
    
    /// <summary>
    /// Style Sheet Asset路径
    /// </summary>
    protected virtual string StyleSheetAssetPath
    {
        get
        {
            return  "Assets/Scripts/Editor/UIToolkitStudy/UIBTGraphEditorWindow/DefaultGraphStyleSheet.uss";
        }
    }
    
    public BehaviourTreeGraphView()
    {
        mAvailableNodeTypeList = new List<NodeType>() ;
        mSelectedNodeChangeDelegate = null;
        Init();
    }

    /// <summary>
    /// 带参构造函数
    /// </summary>
    /// <param name="availableNodeTypeList"></param>
    /// <param name="selectedNodeChangeCB"></param>
    public BehaviourTreeGraphView(List<NodeType> availableNodeTypeList, Action<NodeView> selectedNodeChangeCB = null)
    {
        mAvailableNodeTypeList = availableNodeTypeList;
        mSelectedNodeChangeDelegate += selectedNodeChangeCB;
        Init();
    }
    
    /// <summary>
    /// 初始化
    /// </summary>
    protected virtual void Init()
    {
        ******
        LoadStyleSheet();
        ******
    }
    
    /// <summary>
    /// 加载Style Sheet
    /// </summary>
    protected virtual void LoadStyleSheet()
    {
        var styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(StyleSheetAssetPath);
        styleSheets.Add(styleSheet);
    }

    ******
}

/// <summary>
/// BehaviourTreeGraphView.cs
/// 行为树GraphView
/// </summary>
public class BehaviourTreeGraphView : GraphView
{
    /// <summary>
    /// 节点默认Rect
    /// </summary>
    protected readonly Rect NodeDefaultRect = new Rect(100, 200, 100, 150);
    
    /// <summary>
    /// 根节点类型(子类重写实现自定义不同根节点类型)
    /// </summary>
    protected readonly Type RootNodeType = BTGraphConstEditor.RootNodeType;

    /// <summary>
    /// GraphView朝向
    /// </summary>
    protected virtual Orientation GraphOrientation
    {
        get
        {
            return GraphOrientation.Horizontal;
        }
    }
    
    *******

    /// <summary>
    /// 初始化
    /// </summary>
    protected virtual void Init()
    {
        ******
        AddEntryPointNode();
        ******
    }
    
    /// <summary>
    /// 添加根节点
    /// </summary>
    protected virtual void AddEntryPointNode()
    {
        AddElement(GenerateEntryPointNode());
    }

    /// <summary>
    /// 生成根节点
    /// </summary>
    /// <returns></returns>
    protected NodeView GenerateEntryPointNode()
    {
        var rootNode = CreateNodeByType(RootNodeType, BTGraphConstEditor.NodeDefaultPos);
        return rootNode;
    }

    /// <summary>
    /// 创建指定节点名的新节点
    /// </summary>
    /// <param name="isEntryNode">是否是根节点</param>
    /// <param name="addNodeData">是否添加节点数据</param>
    /// <returns></returns>
    public virtual NodeView CreateNode<T>(bool isEntryNode = false, bool addNodeData = true) where T : BaseNode, new()
    {
        var typeInfo = typeof(T);
        var nodeView = CreateNodeByType(typeInfo, isEntryNode, addNodeData);
        return nodeView;
    }

    /// <summary>
    /// 创建指定类型信息和节点名的新节点
    /// </summary>
    /// <param name="typeInfo">类型信息</param>
    /// <param name="position"></param>
    /// <param name="isEntryNode">是否是根节点</param>
    /// <returns></returns>
    public NodeView CreateNodeByType(Type typeInfo, Vector2 position)
    {
        var newNode = BTGraphUtilitiesEditor.CreateNodeInstance(typeInfo);
        var guid = Guid.NewGuid().ToString();
        var nodeRect = BTGraphConstEditor.NodeDefaultRect;
        nodeRect.x = position.x;
        nodeRect.y = position.y;
        newNode.Init(guid, nodeRect);
        var nodeView = BTGraphUtilitiesEditor.CreateNodeViewInstance(typeInfo);
        nodeView.Init(SourceGraphData, newNode, OnNodeSelected, null, GraphOrientation);
        AddNodeData(newNode);
        AddElement(nodeView);
        UpdateNodeViewRect(nodeView, nodeRect);
        return nodeView;
    }
    
    /// <summary>
    /// 更新NodeView的Rect信息(同时自动更新Node节点数据的Rect信息)
    /// </summary>
    /// <param name="nodeView"></param>
    /// <param name="position"></param>
    protected bool UpdateNodeViewRect(NodeView nodeView, Rect position)
    {
        if (nodeView == null)
        {
            Debug.LogError($"不允许更新空NodeView的位置数据！");
            return false;
        }
        nodeView.SetPosition(position);
        return true;
    }

	/// <summary>
    /// 添加新节点数据
    /// </summary>
    /// <param name="node"></param>
    /// <param name="enableUndoSystem"></param>
    protected bool AddNodeData(BaseNode node, bool enableUndoSystem = true)
    {
        if (node == null)
        {
            Debug.LogError($"不允许添加空节点数据！");
            return false;
        }
        if (enableUndoSystem)
        {
            Undo.RecordObject(SourceGraphData, "AddNodeData");
        }
        var result = SourceGraphData.AddNode(node);
        if (result)
        {
            OnAddNodeData(node);
            EditorUtility.SetDirty(SourceGraphData);
        }
        return true;
    }
    
    ******
}

/// <summary>
/// BTGraphUtilitiesEditor.cs
/// 行为树节点编辑器工具类
/// </summary>
public static class BTGraphUtilitiesEditor
{
   ******
    
    /// <summary>
    /// 创建指定Node类型信息实例对象
    /// </summary>
    /// <param name="typeInfo"></param>
    /// <returns></returns>
    public static BaseNode CreateNodeInstance(Type typeInfo)
    {
        if(typeInfo == null)
        {
            Debug.LogError($"不支持创建空类型信息的节点对象！");
            return null;
        }
        if(typeInfo != CommonGraphConstEditor.BaseNodeType && !typeInfo.IsSubclassOf(CommonGraphConstEditor.BaseNodeType))
        {
            Debug.LogError($"不允许创建未继承BaseNode的类型:{typeInfo.Name}信息节点对象！");
            return null;
        }
        // TODO: 硬编码类型构建避免反射
        return ScriptableObject.CreateInstance(typeInfo) as BaseNode;
    }

    /// <summary>
    /// 创建指定Node类型信息的NodeView实例对象
    /// </summary>
    /// <param name="typeInfo"></param>
    /// <returns></returns>
    public static NodeView CreateNodeViewInstance(Type typeInfo)
    {
        if (typeInfo == null)
        {
            Debug.LogError($"不支持创建空类型信息的节点View对象！");
            return null;
        }
        var nodeViewType = GetNodeViewType(typeInfo);
        // TODO: 硬编码类型构建避免反射
        if (nodeViewType != CommonGraphConstEditor.NodeViewType && !nodeViewType.IsSubclassOf(CommonGraphConstEditor.NodeViewType))
        {
            Debug.LogError($"不允许创建未继承BaseNode的类型:{nodeViewType.Name}信息节点View对象！");
            return null;
        }
        return Activator.CreateInstance(nodeViewType) as NodeView;
    }
    
    ******
}

/// <summary>
/// NodeState.cs
/// 节点状态
/// </summary>
public enum NodeState
{
    Suspend = 0,        // 挂起状态
    Running,            // 运行状态
    Abort,              // 被打断状态
    Success,            // 成功状态
    Failed,             // 失败状态
}

/// <summary>
/// BaseNode.cs
/// 节点数据基类
/// </summary>
[Serializable]
public class BaseNode : Node
{
    /// <summary>
    /// 唯一ID
    /// </summary>
    [Header("唯一ID")]
    public string GUID;

    /// <summary>
    /// 位置
    /// </summary>
    [Header("位置")]
    [HideInInspector]
    public Rect Position;

    /// <summary>
    /// 节点描述
    /// </summary>
    [Header("节点描述")]
    [HideInInspector]
    public string Des = "节点描述";

    /// <summary>
    /// 是否是根节点
    /// </summary>
    public virtual bool EntryPoint
    {
        get
        {
            return false;
        }
    }

    /// <summary>
    /// 节点类型(子类重写自定义节点类型)
    /// </summary>
    public virtual NodeType NodeType
    {
        get
        {
            return NodeType.Composition;
        }
    }

    /// <summary>
    /// 节点状态
    /// </summary>
    public NodeState NodeState
    {
        get;
        protected set;
    }

    /// <summary>
    /// 是否进入过打断(辅助调试信息显示)
    /// </summary>
    public bool IsEnteredAbort
    {
        get;
        protected set;
    }

    /// <summary>
    /// 无参构造
    /// </summary>
    public BaseNode()
    {
		******
    }

    /// <summary>
    /// 初始化
    /// </summary>
    /// <param name="guid">唯一ID</param>
    /// <param name="position"></param>
    /// <param name="nodeState">节点状态</param>
    public void Init(string guid, Rect position, NodeState nodeState = NodeState.Suspend)
    {
        GUID = guid;
        Position = position;
        NodeState = nodeState;
        IsEnteredAbort = false;
        name = GetType().Name;
    }
}

/// <summary>
/// NodeView.cs
/// 节点显示抽象
/// </summary>
public class NodeView : Node
{
    /// <summary>
    /// 所属图数据
    /// </summary>
    public BehaviourTreeGraphData OwnerGraphData
    {
        get;
        private set;
    }

    /// <summary>
    /// 节点数据
    /// </summary>
    public BaseNode NodeData
    {
        get;
        private set;
    }

    /// <summary>
    /// 入口Port连线数量类型
    /// </summary>
    public virtual Port.Capacity InPortCapacity
    {
        get
        {
            return Port.Capacity.Single;
        }
    }

    /// <summary>
    /// 出口Port连线数量类型
    /// </summary>
    public virtual Port.Capacity OutPortCapacity
    {
        get
        {
            return Port.Capacity.Single;
        }
    }

    /// <summary>
    /// 节点朝向
    /// </summary>
    protected Orientation mOrientation;

    /// <summary>
    /// 节点选择委托
    /// </summary>
    protected Action<NodeView> mNodeSelectedDelegate;

    /// <summary>
    /// 所有输入端口
    /// </summary>
    protected List<Port> mAllInputPorts;

    /// <summary>
    /// 所有输出端口
    /// </summary>
    protected List<Port> mAllOutputPorts;

    /// <summary>
    /// 无参构造
    /// </summary>
    public NodeView()
    {
        mAllInputPorts = new List<Port>();
        mAllOutputPorts = new List<Port>();
    }

    /// <summary>
    /// 带参构造
    /// </summary>
    /// <param name="ownerGraphData">所属图数据</param>
    /// <param name="nodeData">节点数据</param>
    /// <param name="nodeSelectedCB">节点选择委托</param>
    /// <param name="nodeName">节点名(默认不传为BaseNode的类型名)</param>
    /// <param name="orientation">节点方向</param>
    public NodeView(BehaviourTreeGraphData ownerGraphData, BaseNode nodeData, Action<NodeView> nodeSelectedCB = null, string nodeName = null, Orientation orientation = Orientation.Horizontal)
    {
        Init(ownerGraphData, nodeData, nodeSelectedCB, nodeName, orientation);
    }
    
	/// <summary>
    /// 根据Node数据初始化
    /// </summary>
    /// <param name="ownerGraphData">所属图数据</param>
    /// <param name="nodeData">节点数据</param>
    /// <param name="nodeSelectedCB">节点选择委托</param>
    /// <param name="nodeName">节点名(默认不传为BaseNode的类型名)</param>
    /// <param name="orientation">节点方向</param>
    public void Init(BehaviourTreeGraphData ownerGraphData, BaseNode node, Action<NodeView> nodeSelectedCB = null, string nodeName = null, Orientation orientation = Orientation.Horizontal)
    {
        OwnerGraphData = ownerGraphData;
        name = node.GUID;
        // viewDataKey是GraphView.GetNodeByGUID的数据来源
        viewDataKey = node.GUID;
        NodeData = node;
        mNodeSelectedDelegate += nodeSelectedCB;
        mOrientation = orientation;
        title = nodeName == null ? node.GetType().Name : nodeName;
        titleContainer.style.backgroundColor = BTGraphUtilitiesEditor.GetBackgroundColorByNodeData(NodeData);
        var titleLabel = titleContainer.Q<Label>("title-label");
        titleLabel.style.color = Color.black;
        titleLabel.style.fontSize = BTGraphConstEditor.NormalLabelFontSize;
        CreateNodeUI();
        GenerateAllPort();
        RefreshExpandedState();
        RefreshPorts();
    }


    ******

    /// <summary>
    /// 创建节点UI
    /// </summary>
    protected void CreateNodeUI()
    {
        CreateNodeContainerUI();
        CreateNodeGUIDUI();
        CreateNodeStateUI();
        CreateCustomUI();
        CreateNodeDesUI();
    }

    /// <summary>
    /// 创建节点UI
    /// </summary>
    protected void CreateNodeContainerUI()
    {
        var nodeVerticalUIContainer = UIToolkitUtilities.CreateVerticalContainer(BTGraphElementNames.NodeUIVerticalContainerName,
                                                                                 1, "unity-box", 0, 0, 0, 0,
                                                                                 BTGraphConstEditor.NodeContainerBGColor);
        var nodeContentElement = this.Q<VisualElement>("contents");
        nodeContentElement.Insert(0, nodeVerticalUIContainer);
    }

    /// <summary>
    /// 创建节点GUID UI
    /// </summary>
    protected void CreateNodeGUIDUI()
    {
        var nodeVerticalUIContainer = this.Q<VisualElement>(BTGraphElementNames.NodeUIVerticalContainerName);
        var nodeGUIDHorizontalUIContainer = UIToolkitUtilities.CreateHorizontalContainer(BTGraphElementNames.NodeGUIDUIHorizontalContainerName);

        var nodeGUIDDivider = UIToolkitUtilities.CreateHorizontalDivider(BTGraphConstEditor.DividerColor);
        nodeVerticalUIContainer.Add(nodeGUIDDivider);
        nodeVerticalUIContainer.Add(nodeGUIDHorizontalUIContainer);

        var nodeGuidTitleLabel = new Label();
        nodeGuidTitleLabel.text = "GUID:";
        nodeGuidTitleLabel.style.height = BTGraphConstEditor.NodeOneLineHeight;
        nodeGuidTitleLabel.style.fontSize = BTGraphConstEditor.NormalLabelFontSize;
        nodeGuidTitleLabel.style.unityTextAlign = TextAnchor.MiddleCenter;
        nodeGuidTitleLabel.style.alignSelf = Align.Center;
        nodeGUIDHorizontalUIContainer.Add(nodeGuidTitleLabel);

        var nodeGuidLabel = new TextField();
        nodeGuidLabel.isReadOnly = true;
        nodeGuidLabel.value = NodeData.GUID;
        nodeGuidLabel.style.height = BTGraphConstEditor.NodeOneLineHeight;
        nodeGuidLabel.style.fontSize = BTGraphConstEditor.NormalLabelFontSize;
        nodeGuidLabel.style.unityTextAlign = TextAnchor.MiddleCenter;
        nodeGuidLabel.style.alignSelf = Align.Center;
        //nodeGuidLabel.style.color = Color.white;
        nodeGUIDHorizontalUIContainer.Add(nodeGuidLabel);
    }

    /// <summary>
    /// 创建节点状态UI
    /// </summary>
    protected void CreateNodeStateUI()
    {
        var nodeVerticalUIContainer = this.Q<VisualElement>(BTGraphElementNames.NodeUIVerticalContainerName);
        var nodeStateHorizontalUIContainer = UIToolkitUtilities.CreateHorizontalContainer(BTGraphElementNames.NodeStateUIHorizontalContainerName);

        var nodeStateDivider = UIToolkitUtilities.CreateHorizontalDivider(BTGraphConstEditor.DividerColor);
        nodeVerticalUIContainer.Add(nodeStateDivider);
        nodeVerticalUIContainer.Add(nodeStateHorizontalUIContainer);

        var nodeStateTitleLabel = new Label();
        nodeStateTitleLabel.style.width = 40f;
        nodeStateTitleLabel.style.height = BTGraphConstEditor.NodeOneLineHeight;
        nodeStateTitleLabel.text = "状态:";
        nodeStateTitleLabel.style.fontSize = BTGraphConstEditor.NormalLabelFontSize;
        nodeStateTitleLabel.style.color = Color.black;
        nodeStateTitleLabel.style.unityTextAlign = TextAnchor.MiddleCenter;
        nodeStateTitleLabel.style.alignSelf = Align.Center;
        nodeStateHorizontalUIContainer.Add(nodeStateTitleLabel);

        var nodeStateLabel = new Label();
        nodeStateLabel.name = BTGraphElementNames.NodeStateLabelName;
        nodeStateLabel.style.width = 40f;
        nodeStateLabel.style.unityTextAlign = TextAnchor.MiddleCenter;
        nodeStateLabel.style.alignSelf = Align.Center;
        nodeStateLabel.style.height = BTGraphConstEditor.NodeOneLineHeight;
        nodeStateLabel.style.fontSize = BTGraphConstEditor.NormalLabelFontSize;
        nodeStateLabel.style.color = Color.black;
        nodeStateLabel.style.flexGrow = 1;
        nodeStateHorizontalUIContainer.Add(nodeStateLabel);
        UpdateNodeStateBackgroundColor();
        UpdateNodeStateLabel();
    }

    /// <summary>
    /// 创建节点自定义UI
    /// </summary>
    protected virtual void CreateCustomUI()
    {

    }

    /// <summary>
    /// 更新节点状态背景颜色
    /// </summary>
    public void UpdateNodeStateBackgroundColor()
    {
        var nodeStateHorizontalUIContainer = this.Q<VisualElement>(BTGraphElementNames.NodeStateUIHorizontalContainerName);
        if(nodeStateHorizontalUIContainer != null)
        {
            nodeStateHorizontalUIContainer.style.backgroundColor = BTGraphUtilitiesEditor.GetColorByNodeState(NodeData.NodeState);
        }
    }

    /// <summary>
    /// 更新节点状态Label
    /// </summary>
    public void UpdateNodeStateLabel()
    {
        var nodeStateLabel = this.Q<Label>(BTGraphElementNames.NodeStateLabelName);
        if (nodeStateLabel != null)
        {
            var stateDes = NodeData.NodeState.ToString();
            if(NodeData.IsEnteredAbort)
            {
                stateDes = $"{stateDes}(打断)";
            }
            nodeStateLabel.text = stateDes;
        }
    }

    /// <summary>
    /// 创建节点描述UI
    /// </summary>
    protected void CreateNodeDesUI()
    {
        var nodeVerticalUIContainer = this.Q<VisualElement>(BTGraphElementNames.NodeUIVerticalContainerName);
        var nodeDesHorizontalUIContainer = UIToolkitUtilities.CreateHorizontalContainer(BTGraphElementNames.NodeDesUIHorizontalContainerName);

        var nodeDesDivider = UIToolkitUtilities.CreateHorizontalDivider(BTGraphConstEditor.DividerColor);
        nodeVerticalUIContainer.Add(nodeDesDivider);
        nodeVerticalUIContainer.Add(nodeDesHorizontalUIContainer);

        UIToolkitUtilities.CreateBindSOTextField(nodeDesHorizontalUIContainer, NodeData,
                                                 BTGraphConstEditor.NodeDesPropertyName, 1,
                                                 BTGraphConstEditor.NodeOneLineHeight,
                                                 BTGraphConstEditor.NormalLabelFontSize);
    }

    /// <summary>
    /// 创建节点自定义UI
    /// </summary>
    protected virtual void CreateCustomUI()
    {

    }
    
    ******
}

/// <summary>
/// BTGraphUtilitiesEditor.cs
/// 行为树节点编辑器工具类
/// </summary>
public static class BTGraphUtilitiesEditor
{
    ******

    /// <summary>
    /// 节点类型和颜色背景Map
    /// </summary>
    private static Dictionary<NodeType, Color> NodeTypeBackgroundColorMap = new Dictionary<NodeType, Color>
    {
        {NodeType.Composition, Color.blue},
        {NodeType.Decoration, Color.cyan},
        {NodeType.Condition, Color.yellow},
        {NodeType.Action, Color.red},
    };

    /// <summary>
    /// 节点状态和颜色背景Map
    /// </summary>
    private static readonly Dictionary<NodeState, Color> NodeStateColorMap = new Dictionary<NodeState, Color>
    {
        {NodeState.Suspend, Color.grey},
        {NodeState.Running, Color.yellow},
        {NodeState.Abort, Color.magenta},
        {NodeState.Success, Color.green},
        {NodeState.Failed, Color.red},
    };

    ******

    /// <summary>
    /// 获取指定节点类型的背景颜色
    /// </summary>
    /// <param name="nodeType"></param>
    /// <returns></returns>
    public static Color GetBackgroundColorByNodeType(NodeType nodeType)
    {
        Color nodeTypeBackgroundColor;
        if (NodeTypeBackgroundColorMap.TryGetValue(nodeType, out nodeTypeBackgroundColor))
        {
            return nodeTypeBackgroundColor;
        }
        Debug.LogError($"未配置节点类型:{nodeType}的背景颜色！");
        return Color.grey;
    }

    /// <summary>
    /// 获取指定节点类型的背景颜色
    /// </summary>
    /// <param name="nodeState"></param>
    /// <returns></returns>
    public static Color GetColorByNodeState(NodeState nodeState)
    {
        Color nodeStateColor;
        if (NodeStateColorMap.TryGetValue(nodeState, out nodeStateColor))
        {
            return nodeStateColor;
        }
        Debug.LogError($"未配置节点状态:{nodeState}的颜色！");
        return Color.grey;
    }
    
    ******
}

/// <summary>
/// UIToolkitUtilities.cs
/// UIToolkit工具类
/// </summary>
public static class UIToolkitUtilities
{
    /// <summary>
    /// 创建一个指定名字指定相关设置的横向容器
    /// </summary>
    /// <param name="containerName"></param>
    /// <param name="flexGrow"></param>
    /// <param name="classList"></param>
    /// <param name="styleLeft"></param>
    /// <param name="styleRight"></param>
    /// <param name="styleTop"></param>
    /// <param name="styleBottom"></param>
    /// <param name="styleColor"></param>
    /// <returns></returns>
    public static VisualElement CreateHorizontalContainer(string containerName, float flexGrow = 1f, string classList = null, float styleLeft = 0, float styleRight = 0, float styleTop = 0, float styleBottom = 0, StyleColor styleColor = default(StyleColor))
    {
        var nodeHorizontalUIContainer = new VisualElement();
        nodeHorizontalUIContainer.name = containerName;
        nodeHorizontalUIContainer.style.left = styleLeft;
        nodeHorizontalUIContainer.style.right = styleRight;
        nodeHorizontalUIContainer.style.flexGrow = flexGrow;
        nodeHorizontalUIContainer.style.top = styleTop;
        nodeHorizontalUIContainer.style.bottom = styleBottom;
        nodeHorizontalUIContainer.style.flexDirection = FlexDirection.Row;
        nodeHorizontalUIContainer.style.backgroundColor = styleColor;
        if(!string.IsNullOrEmpty(classList))
        {
            nodeHorizontalUIContainer.AddToClassList(classList);
        }
        return nodeHorizontalUIContainer;
    }

    /// <summary>
    /// 创建一个指定名字指定相关设置的竖向容器
    /// </summary>
    /// <param name="containerName"></param>
    /// <param name="flexGrow"></param>
    /// <param name="classList"></param>
    /// <param name="styleLeft"></param>
    /// <param name="styleRight"></param>
    /// <param name="styleTop"></param>
    /// <param name="styleBottom"></param>
    /// <param name="styleColor"></param>
    /// <returns></returns>
    public static VisualElement CreateVerticalContainer(string containerName, float flexGrow = 1f, string classList = null, float styleLeft = 0, float styleRight = 0, float styleTop = 0, float styleBottom = 0, StyleColor styleColor = default(StyleColor))
    {
        var nodeHorizontalUIContainer = new VisualElement();
        nodeHorizontalUIContainer.name = containerName;
        nodeHorizontalUIContainer.style.left = styleLeft;
        nodeHorizontalUIContainer.style.right = styleRight;
        nodeHorizontalUIContainer.style.flexGrow = flexGrow;
        nodeHorizontalUIContainer.style.top = styleTop;
        nodeHorizontalUIContainer.style.bottom = styleBottom;
        nodeHorizontalUIContainer.style.flexDirection = FlexDirection.Column;
        nodeHorizontalUIContainer.style.backgroundColor = styleColor;
        if (!string.IsNullOrEmpty(classList))
        {
            nodeHorizontalUIContainer.AddToClassList(classList);
        }
        return nodeHorizontalUIContainer;
    }

    /// <summary>
    /// 创建一个横向分割线
    /// </summary>
    /// <param name="color"></param>
    /// <returns></returns>
    public static VisualElement CreateHorizontalDivider(Color color, float height = 1f)
    {
        var horizontalDivider = new VisualElement();
        horizontalDivider.style.height = height;
        horizontalDivider.style.flexGrow = 1;
        horizontalDivider.style.backgroundColor = color;
        return horizontalDivider;
    }

    /// <summary>
    /// 创建一个竖向分割线
    /// </summary>
    /// <param name="color"></param>
    /// <returns></returns>
    public static VisualElement CreateVerticalDivider(Color color)
    {
        var horizontalDivider = new VisualElement();
        horizontalDivider.style.width = 1;
        horizontalDivider.style.flexGrow = 1;
        horizontalDivider.style.backgroundColor = color;
        return horizontalDivider;
    }

    /// <summary>
    /// 指定容器创建指定对象的可视化Inspector
    /// </summary>
    /// <param name="scriptableObject"></param>
    /// <param name="propertyBindDataMap"></param>
    public static VisualElement CreateBindSOInspector(ScriptableObject scriptableObject, Dictionary<string, PropertyBindData> propertyBindDataMap = null)
    {
        if(scriptableObject == null)
        {
            Debug.LogError($"不允许给空ScriptableObject创建可视化Inspector！");
            return null;
        }
        var container = CreateVerticalContainer(null, 1);
        var serializedObject = new SerializedObject(scriptableObject);
        var propertyIterator = serializedObject.GetIterator();
        propertyIterator.NextVisible(true);
        while(propertyIterator.NextVisible(false))
        {
            var propertyField = new PropertyField();
            var propertyName = propertyIterator.name;
            var property = serializedObject.FindProperty(propertyName);
            propertyField.name = propertyName;
            propertyField.BindProperty(property);
            container.Add(propertyField);
            if(propertyBindDataMap != null)
            {
                var propertyBindData = new PropertyBindData(serializedObject, property, propertyField);
                propertyBindDataMap.Add(propertyName, propertyBindData);
            }
        }
        return container;
    }

    /// <summary>
    /// 指定容器创建指定对象指定属性名的绑定PropertyField
    /// </summary>
    /// <param name="container"></param>
    /// <param name="scriptableObject"></param>
    /// <param name="propertyName"></param>
    /// <param name="flexGrow"></param>
    /// <param name="height"></param>
    public static PropertyBindData CreateBindSOPropertyField(VisualElement container, ScriptableObject scriptableObject, string propertyName, float flexGrow = 0, float height = 25f)
    {
        if (container == null)
        {
            Debug.LogError($"不允许给空容器创建绑定PropertyField！");
            return null;
        }
        if (scriptableObject == null)
        {
            Debug.LogError($"不允许给空ScriptableObject创建绑定PropertyField！");
            return null;
        }
        var serializedObject = new SerializedObject(scriptableObject);
        var property = serializedObject.FindProperty(propertyName);
        if(property == null)
        {
            Debug.LogError($"ScriptableObject:{scriptableObject.name}没找到属性名:{propertyName}的属性，创建绑定PropertyField失败！");
            return null;
        }
        var propertyField = new PropertyField();
        propertyField.name = propertyName;
        propertyField.BindProperty(property);
        propertyField.style.height = height;
        propertyField.style.flexGrow = flexGrow;
        container.Add(propertyField);
        var propertyBindData = new PropertyBindData(serializedObject, property, propertyField);
        return propertyBindData;
    }

    /// <summary>
    /// 指定容器创建指定对象指定属性名的绑定TextField
    /// </summary>
    /// <param name="container"></param>
    /// <param name="scriptableObject"></param>
    /// <param name="propertyName"></param>
    /// <param name="flexGrow"></param>
    /// <param name="height"></param>
    /// <param name="fontSize"></param>
    /// <param name="textAnchor"></param>
    public static PropertyBindData CreateBindSOTextField(VisualElement container, ScriptableObject scriptableObject, string propertyName, float flexGrow = 0, float height = 25f, float fontSize = 15f, TextAnchor textAnchor = TextAnchor.MiddleCenter)
    {
        if (container == null)
        {
            Debug.LogError($"不允许给空容器创建绑定TextField！");
            return null;
        }
        if (scriptableObject == null)
        {
            Debug.LogError($"不允许给空ScriptableObject创建绑定TextField！");
            return null;
        }
        var serializedObject = new SerializedObject(scriptableObject);
        var property = serializedObject.FindProperty(propertyName);
        if (property == null)
        {
            Debug.LogError($"ScriptableObject:{scriptableObject.name}没找到属性名:{propertyName}的属性，创建绑定TextField失败！");
            return null;
        }
        var textField = new TextField();
        textField.name = propertyName;
        textField.BindProperty(property);
        textField.style.height = height;
        textField.style.fontSize = fontSize;
        textField.style.flexGrow = flexGrow;
        textField.style.unityTextAlign = textAnchor;
        container.Add(textField);
        var propertyBindData = new PropertyBindData(serializedObject, property, textField);
        return propertyBindData;
    }
    
    ******
}

/// <summary>
/// NodeView.cs
/// 节点显示抽象
/// </summary>
public class NodeView : Node
{
    /// <summary>
    /// 所属图数据
    /// </summary>
    public BehaviourTreeGraphData OwnerGraphData
    {
        get;
        private set;
    }

    /// <summary>
    /// 节点数据
    /// </summary>
    public BaseNode NodeData
    {
        get;
        private set;
    }

    /// <summary>
    /// 入口Port连线数量类型
    /// </summary>
    public virtual Port.Capacity InPortCapacity
    {
        get
        {
            return Port.Capacity.Single;
        }
    }

    /// <summary>
    /// 出口Port连线数量类型
    /// </summary>
    public virtual Port.Capacity OutPortCapacity
    {
        get
        {
            return Port.Capacity.Single;
        }
    }

    /// <summary>
    /// 节点朝向
    /// </summary>
    protected Orientation mOrientation;

    /// <summary>
    /// 节点选择委托
    /// </summary>
    protected Action<NodeView> mNodeSelectedDelegate;

    /// <summary>
    /// 所有输入端口
    /// </summary>
    protected List<Port> mAllInputPorts;

    /// <summary>
    /// 所有输出端口
    /// </summary>
    protected List<Port> mAllOutputPorts;
    
    /// <summary>
    /// 无参构造
    /// </summary>
    public NodeView()
    {
		mAllInputPorts = new List<Port>();
        mAllOutputPorts = new List<Port>();
    }

    /// <summary>
    /// 带参构造
    /// </summary>
    /// <param name="ownerGraphData">所属图数据</param>
    /// <param name="nodeData">节点数据</param>
    /// <param name="nodeSelectedCB">节点选择委托</param>
    /// <param name="nodeName">节点名(默认不传为BaseNode的类型名)</param>
    /// <param name="orientation">节点方向</param>
    public NodeView(BehaviourTreeGraphData ownerGraphData, BaseNode nodeData, Action<NodeView> nodeSelectedCB = null, string nodeName = null, Orientation orientation = Orientation.Horizontal)
    {
        Init(ownerGraphData, nodeData, nodeSelectedCB, nodeName, orientation);
    }

    /// <summary>
    /// 根据Node数据初始化
    /// </summary>
    /// <param name="ownerGraphData">所属图数据</param>
    /// <param name="nodeData">节点数据</param>
    /// <param name="nodeSelectedCB">节点选择委托</param>
    /// <param name="nodeName">节点名(默认不传为BaseNode的类型名)</param>
    /// <param name="orientation">节点方向</param>
    public void Init(BehaviourTreeGraphData ownerGraphData, BaseNode node, Action<NodeView> nodeSelectedCB = null, string nodeName = null, Orientation orientation = Orientation.Horizontal)
    {
        OwnerGraphData = ownerGraphData;
        name = node.GUID;
        // viewDataKey是GraphView.GetNodeByGUID的数据来源
        viewDataKey = node.GUID;
        NodeData = node;
        mNodeSelectedDelegate += nodeSelectedCB;
        mOrientation = orientation;
        title = nodeName == null ? node.GetType().Name : nodeName;
        titleContainer.style.backgroundColor = BTGraphUtilitiesEditor.GetBackgroundColorByNodeData(NodeData);
        var titleLabel = titleContainer.Q<Label>("title-label");
        titleLabel.style.color = Color.black;
        titleLabel.style.fontSize = BTGraphConstEditor.NormalLabelFontSize;
        CreateNodeUI();
        GenerateAllPort();
        RefreshExpandedState();
        RefreshPorts();
    }

    /// <summary>
    /// 创建自定义输入Port
    /// </summary>
    /// <param name="portName"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    public Port InstantiateCustomInputPort(string portName, System.Type type)
    {
        var port = InstantiateCustomPort(portName, Direction.Input, InPortCapacity, type);
        inputContainer.Add(port);
        mAllInputPorts.Add(port);
        return port;
    }

    /// <summary>
    /// 创建自定义输出Port
    /// </summary>
    /// <param name="portName"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    public Port InstantiateCustomOutputPort(string portName, System.Type type)
    {
        var port = InstantiateCustomPort(portName, Direction.Output, OutPortCapacity, type);
        outputContainer.Add(port);
        mAllOutputPorts.Add(port);
        return port;
    }

    /// <summary>
    /// 获取所有Input端口
    /// </summary>
    /// <returns></returns>
    public List<Port> GetAllInputPorts()
    {
        return mAllInputPorts;
    }

    /// <summary>
    /// 获取所有Output端口
    /// </summary>
    /// <returns></returns>
    public List<Port> GetAllOutputPorts()
    {
        return mAllOutputPorts;
    }

    /// <summary>
    /// 创建自定义Port
    /// Note:
    /// 不含添加到容器
    /// </summary>
    /// <param name="portName"></param>
    /// <param name="direction"></param>
    /// <param name="capacity"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    protected virtual Port InstantiateCustomPort(string portName, Direction direction, Port.Capacity capacity, System.Type type)
    {
        var port = InstantiatePort(mOrientation, direction, capacity, type);
        port.name = portName;
        port.portName = portName;
        return port;
    }

    /// <summary>
    /// 实例化Port(自定义Port创建接口用于支持创建自定义EdgeView)
    /// </summary>
    /// <param name="orientation"></param>
    /// <param name="direction"></param>
    /// <param name="capacity"></param>
    /// <param name="type"></param>
    /// <returns></returns>
    public override Port InstantiatePort(Orientation orientation, Direction direction, Port.Capacity capacity, Type type)
    {
        return Port.Create<EdgeView>(orientation, direction, capacity, type);
    }

    ******
    
    /// <summary>
    /// 创建所有Port
    /// </summary>
    protected void GenerateAllPort()
    {
        GenerateAllInputPort();
        GenerateAllOutputPort();
    }

    /// <summary>
    /// 生成节点所有Input Port
    /// </summary>
    protected virtual void GenerateAllInputPort()
    {
        InstantiateCustomInputPort(BTGraphConstEditor.DefaultInputPortName, BTGraphConstEditor.FloatType);
    }

    /// <summary>
    /// 生成节点所有Output Port
    /// </summary>
    protected virtual void GenerateAllOutputPort()
    {
        InstantiateCustomOutputPort(BTGraphConstEditor.DefaultOutputPortName, BTGraphConstEditor.FloatType);
    }

    ******
}