#if GRAPH_DESIGNER
/// ---------------------------------------------
/// Behavior Designer
/// Copyright (c) Opsive. All Rights Reserved.
/// https://www.opsive.com
/// ---------------------------------------------
namespace Opsive.BehaviorDesigner.Runtime
{
    using Opsive.BehaviorDesigner.Runtime.Tasks;
    using Opsive.BehaviorDesigner.Runtime.Tasks.Events;
    using Opsive.GraphDesigner.Runtime;
    using Opsive.GraphDesigner.Runtime.Utility;
    using Opsive.GraphDesigner.Runtime.Variables;
    using Opsive.Shared.Utility;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Reflection;
    using UnityEngine;

    /// <summary>
    /// Storage class for the graph data.
    /// </summary>
    [System.Serializable]
    public class BehaviorTreeData
    {
        [Tooltip("The serialized Task data.")]
        [SerializeField] private Serialization[] m_TaskData;
        [Tooltip("The serialized EventTask data.")]
        [SerializeField] private Serialization[] m_EventTaskData;
        [Tooltip("The serialized SharedVariable data.")]
        [SerializeField] private Serialization[] m_SharedVariableData;
        [Tooltip("The serialized disabled event nodes data.")]
        [SerializeField] private Serialization[] m_DisabledEventNodesData;
        [Tooltip("The serialized disabled logic nodes data.")]
        [SerializeField] private Serialization[] m_DisabledLogicNodesData;
        [Tooltip("The unique ID of the data.")]
        [SerializeField] private int m_UniqueID;

        private ILogicNode[] m_Tasks;
        private IEventNode[] m_EventTasks;
        private SharedVariable[] m_SharedVariables;
        private ushort[] m_DisabledLogicNodes;
        private ushort[] m_DisabledEventNodes;
        private Dictionary<VariableAssignment, SharedVariable> m_VariableByNameMap;
        private int m_RuntimeUniqueID;

        public ILogicNode[] LogicNodes
        {
            get => m_Tasks;
            set {
                if (value == null) {
                    m_Tasks = null;
                } else {
                    if (m_Tasks == null) {
                        m_Tasks = new ILogicNode[value.Length];
                    } else if (m_Tasks.Length != value.Length) {
                        Array.Resize(ref m_Tasks, value.Length);
                    }
                    for (int i = 0; i < value.Length; ++i) {
                        m_Tasks[i] = value[i];
                    }
                }
            }
        }
        public IEventNode[] EventNodes
        {
            get => m_EventTasks;
            set {
                if (value == null) {
                    m_EventTasks = null;
                } else {
                    if (m_EventTasks == null) {
                        m_EventTasks = new IEventNode[value.Length];
                    } else if (m_EventTasks.Length != value.Length) {
                        Array.Resize(ref m_EventTasks, value.Length);
                    }
                    for (int i = 0; i < value.Length; ++i) {
                        m_EventTasks[i] = value[i];
                    }
                }
            }
        }
        public SharedVariable[] SharedVariables { get => m_SharedVariables; set => m_SharedVariables = value; }
        public int UniqueID { get => m_RuntimeUniqueID != 0 ? m_RuntimeUniqueID : m_UniqueID; }
        public ushort[] DisabledLogicNodes { get => m_DisabledLogicNodes; set => m_DisabledLogicNodes = value; }
        public ushort[] DisabledEventNodes { get => m_DisabledEventNodes; set => m_DisabledEventNodes = value; }
        internal Dictionary<VariableAssignment, SharedVariable> VariableByNameMap { get => m_VariableByNameMap; set => m_VariableByNameMap = value; }

#if UNITY_EDITOR
        [Tooltip("The serialized logic node properties data.")]
        [SerializeField] private Serialization[] m_LogicNodePropertiesData;
        [Tooltip("The serialized event node properties data.")]
        [SerializeField] private Serialization[] m_EventNodePropertiesData;
        [Tooltip("The serialized group properties data.")]
        [SerializeField] private Serialization[] m_GroupPropertiesData;

        private LogicNodeProperties[] m_LogicNodeProperties;
        private NodeProperties[] m_EventNodeProperties;
        private GroupProperties[] m_GroupProperties;

        public LogicNodeProperties[] LogicNodeProperties { get => m_LogicNodeProperties; set { m_LogicNodeProperties = value; } }
        public NodeProperties[] EventNodeProperties { get => m_EventNodeProperties; set { m_EventNodeProperties = value; } }
        public GroupProperties[] GroupProperties { get => m_GroupProperties; set => m_GroupProperties = value; }
#endif

        private ResizableArray<SubtreeNodesReference> m_SubtreeNodesReference;
        [System.NonSerialized] private bool m_Deserializing;

        internal ResizableArray<SubtreeNodesReference> SubtreeNodesReferences { get => m_SubtreeNodesReference; set => m_SubtreeNodesReference = value; }

        /// <summary>
        /// Default constructor.
        /// </summary>
        public BehaviorTreeData()
        {
            m_UniqueID = Guid.NewGuid().GetHashCode();
        }

        /// <summary>
        /// Adds the specified node.
        /// </summary>
        /// <param name="node">The node that should be added.</param>
        public void AddNode(ILogicNode node)
        {
            if (m_Tasks == null) {
                m_Tasks = new ILogicNode[1];
            } else {
                Array.Resize(ref m_Tasks, m_Tasks.Length + 1);
            }
            node.Index = (ushort)(m_Tasks.Length - 1);
            node.ParentIndex = ushort.MaxValue;
            node.SiblingIndex = ushort.MaxValue;
            node.RuntimeIndex = ushort.MaxValue;
            m_Tasks[m_Tasks.Length - 1] = node;
        }

        /// <summary>
        /// Removes the specified logic node.
        /// </summary>
        /// <param name="node">The node that should be removed.</param>
        /// <returns>True if the node was removed.</returns>
        public bool RemoveNode(ILogicNode node)
        {
            if (m_Tasks == null || node.Index >= m_Tasks.Length) {
                return false;
            }

            var dest = new ILogicNode[m_Tasks.Length - 1];
            Array.Copy(m_Tasks, dest, node.Index);
            Array.Copy(m_Tasks, node.Index + 1, dest, node.Index, m_Tasks.Length - node.Index - 1);
            m_Tasks = dest;
            return true;
        }

        /// <summary>
        /// Adds the specified event node.
        /// </summary>
        /// <param name="eventNode">The event node that should be added.</param>
        public void AddNode(IEventNode eventNode)
        {
            if (m_EventTasks == null) {
                m_EventTasks = new IEventNode[1];
            } else {
                Array.Resize(ref m_EventTasks, m_EventTasks.Length + 1);
            }
            m_EventTasks[m_EventTasks.Length - 1] = eventNode;
        }

        /// <summary>
        /// Removes the specified event node.
        /// </summary>
        /// <param name="eventNode">The event node that should be removed.</param>
        /// <returns>True if the event node was removed.</returns>
        public bool RemoveNode(IEventNode eventNode)
        {
            if (m_EventTasks == null) {
                return false;
            }

            var index = m_EventTasks.IndexOf(eventNode);
            if (index == -1) {
                return false;
            }

            var dest = new IEventNode[m_EventTasks.Length - 1];
            Array.Copy(m_EventTasks, dest, index);
            Array.Copy(m_EventTasks, index + 1, dest, index, m_EventTasks.Length - index - 1);
            m_EventTasks = dest;
            return true;
        }

        /// <summary>
        /// Serializes the behavior tree.
        /// </summary>
        public void Serialize()
        {
            m_TaskData = Serialization.Serialize<ILogicNode>(m_Tasks, ValidateSerializedObject);
            m_EventTaskData = Serialization.Serialize<IEventNode>(m_EventTasks, ValidateSerializedObject);
            SerializeSharedVariables();
            m_DisabledEventNodesData = Serialization.Serialize<ushort>(m_DisabledEventNodes);
            m_DisabledLogicNodesData = Serialization.Serialize<ushort>(m_DisabledLogicNodes);
            m_UniqueID = Guid.NewGuid().GetHashCode();

#if UNITY_EDITOR
            // Ensure the node data is up to date.
            if (m_LogicNodeProperties != null) {
                for (int i = 0; i < m_LogicNodeProperties.Length; ++i) {
                    var nodeData = m_LogicNodeProperties[i].Data;
                    nodeData.ParentIndex = m_Tasks[i].ParentIndex;
                    nodeData.SiblingIndex = m_Tasks[i].SiblingIndex;
                    nodeData.IsParent = m_Tasks[i] is IParentNode;
                    m_LogicNodeProperties[i].Data = nodeData;
                }
            }
            m_LogicNodePropertiesData = Serialization.Serialize<LogicNodeProperties>(m_LogicNodeProperties);
            m_EventNodePropertiesData = Serialization.Serialize<NodeProperties>(m_EventNodeProperties);
            m_GroupPropertiesData = Serialization.Serialize<GroupProperties>(m_GroupProperties);
#endif
        }

        /// <summary>
        /// Validates the serialized object.
        /// </summary>
        /// <param name="type">The type of object.</param>
        /// <param name="field">The field that the object belongs to.</param>
        /// <param name="value">The value of the object</param>
        /// <returns>The validated object.</returns>
        public static Serialization.ValidatedObject ValidateSerializedObject(Type type, FieldInfo field, object value)
        {
            if (value == null) {
                return new Serialization.ValidatedObject() { Type = type, Obj = value };
            }

            // Replace ILogicNode with ushort index values.
            if (typeof(IList).IsAssignableFrom(type)) {
                var elementType = Serializer.GetElementType(type);
                if (typeof(ILogicNode).IsAssignableFrom(elementType)) {
                    if (field == null || field.GetCustomAttribute<InspectNodeAttribute>() == null) {
                        var tasks = value as IList;
                        if (tasks == null) {
                            return new Serialization.ValidatedObject() { Type = type, Obj = value };
                        }

                        var indexValues = new ushort[tasks.Count];
                        for (int i = 0; i < indexValues.Length; ++i) {
                            indexValues[i] = ((ILogicNode)tasks[i]).Index;
                        }
                        return new Serialization.ValidatedObject() { Type = typeof(ushort[]), Obj = indexValues };
                    }
                } else if (Application.isPlaying && (typeof(GameObject).IsAssignableFrom(elementType) || typeof(Component).IsAssignableFrom(elementType))) { // Scene objects cannot be serialized at runtime.
                    var listValue = value as IList;
                    if (listValue != null) {
                        IList objects;
                        if (type.IsArray) {
                            objects = Array.CreateInstance(elementType, listValue.Count);
                        } else {
                            if (type.IsGenericType) {
                                objects = Activator.CreateInstance(typeof(List<>).MakeGenericType(elementType)) as IList;
                            } else {
                                objects = Activator.CreateInstance(type) as IList;
                            }
                        }
                        for (int i = 0; i < listValue.Count; ++i) {
                            GameObject gameObjectValue = null;
                            if (listValue[i] is Component componentValue) {
                                gameObjectValue = componentValue.gameObject;
                            } else {
                                gameObjectValue = listValue[i] as GameObject;
                            }
                            if (gameObjectValue != null && gameObjectValue.scene.IsValid()) {
                                if (type.IsArray) {
                                    objects[i] = null;
                                } else {
                                    objects.Add(null);
                                }
                            } else {
                                if (type.IsArray) {
                                    objects[i] = listValue[i];
                                } else {
                                    objects.Add(listValue[i]);
                                }
                            }
                        }
                        listValue = objects;
                    }
                    return new Serialization.ValidatedObject() { Type = type, Obj = listValue };
                }
            } else if (typeof(ILogicNode).IsAssignableFrom(type)) {
                if (field == null || field.GetCustomAttribute<InspectNodeAttribute>() == null) {
                    return new Serialization.ValidatedObject() { Type = typeof(ushort), Obj = ((ILogicNode)value).Index };
                }
            } else if (Application.isPlaying && (typeof(GameObject).IsAssignableFrom(type) || typeof(Component).IsAssignableFrom(type))) { // Scene objects cannot be serialized at runtime.
                GameObject gameObjectValue = null;
                if (value is Component componentValue) {
                    gameObjectValue = componentValue.gameObject;
                } else {
                    gameObjectValue = value as GameObject;
                }
                if (gameObjectValue != null && gameObjectValue.scene.IsValid()) {
                    return new Serialization.ValidatedObject() { Type = type, Obj = null };
                }
            }
            return new Serialization.ValidatedObject() { Type = type, Obj = value };
        }

        /// <summary>
        /// Serializes the SharedVariables. This allows the SharedVariables to be serialized independently.
        /// </summary>
        public void SerializeSharedVariables()
        {
            m_SharedVariableData = Serialization.Serialize<SharedVariable>(m_SharedVariables);

            // Update the mapping for any variable name changes.
            if (m_VariableByNameMap == null) {
                m_VariableByNameMap = new Dictionary<VariableAssignment, SharedVariable>();
            } else {
                m_VariableByNameMap.Clear();
            }
            if (m_SharedVariables != null) {
                for (int i = 0; i < m_SharedVariables.Length; ++i) {
                    m_VariableByNameMap.Add(new VariableAssignment(m_SharedVariables[i].Name, m_SharedVariables[i].Scope), m_SharedVariables[i]);
                }
            }
        }

        /// <summary>
        /// Internal data structure for restoring a task reference after it has been deserialized.
        /// </summary>
        public struct TaskAssignment
        {
            [Tooltip("The field of the task.")]
            public FieldInfo Field;
            [Tooltip("The task that the field belongs to.")]
            public object Target;
            [Tooltip("The value of the field. This will be the task object that should be assigned after the tree has been loaded.")]
            public object Value;
        }

        /// <summary>
        /// Deserialize the behavior tree.
        /// </summary>
        /// <param name="graphComponent">The component that the graph is being deserialized from.</param>
        /// <param name="graph">The graph that is being deserialized.</param>
        /// <param name="force">Should the behavior tree be force deserialized?</param>
        /// <param name="variableForce">Should the shared variables be force deserialized?</param>
        /// <param name="injectSubtrees">Should the subtrees be injected into the behavior tree?</param>
        /// <param name="canDeepCopyVariables">Can the SharedVariables be deep copied?</param>
        /// <param name="sharedVariableOverrides">A list of SharedVariables that should override the current SharedVariable value.</param>
        /// <returns>True if the tree was deserialized.</returns>
        public bool Deserialize(IGraphComponent graphComponent, IGraph graph, bool force, bool injectSubtrees, bool canDeepCopyVariables = true, SharedVariableOverride[] sharedVariableOverrides = null)
        {
            // No need to deserialize if the data is already deserialized.
            if ((m_Tasks != null || m_EventTasks != null || m_SharedVariables != null) && !force) {
                if (Application.isPlaying && m_RuntimeUniqueID == 0) {
                    m_RuntimeUniqueID = m_UniqueID;
                }
                return true;
            }

            return DeserializeInternal(graphComponent, graph, force, injectSubtrees, canDeepCopyVariables, sharedVariableOverrides);
        }

        /// <summary>
        /// Internal method which deserialize the behavior tree.
        /// </summary>
        /// <param name="graphComponent">The component that the graph is being deserialized from.</param>
        /// <param name="graph">The graph that is being deserialized.</param>
        /// <param name="force">Should the behavior tree be force deserialized?</param>
        /// <param name="injectSubtrees">Should the subtrees be injected into the behavior tree?</param>
        /// <param name="canDeepCopyVariables">Can the SharedVariables be deep copied?</param>
        /// <param name="sharedVariableOverrides">A list of SharedVariables that should override the current SharedVariable value.</param>
        /// <returns>True if the tree was deserialized.</returns>
        private bool DeserializeInternal(IGraphComponent graphComponent, IGraph graph, bool force, bool injectSubtrees, bool canDeepCopyVariables, SharedVariableOverride[] sharedVariableOverrides = null)
        {
            // Prevent the tree from being deserialized recusrively.
            if (m_Deserializing) {
                Debug.LogError($"Error: Unable to deserialize {graph}. This can be caused by recursive subtree references.");
                return false;
            }

            m_Deserializing = true;
            m_RuntimeUniqueID = Application.isPlaying ? m_UniqueID : 0;
            var errorState = false;
#if UNITY_EDITOR
            // Deserialize the properties first so it can be used elsewhere.
            if (m_LogicNodePropertiesData != null && m_LogicNodePropertiesData.Length > 0) {
                m_LogicNodeProperties = new LogicNodeProperties[m_LogicNodePropertiesData.Length];
                for (int i = 0; i < m_LogicNodePropertiesData.Length; ++i) {
                    try {
                        m_LogicNodeProperties[i] = m_LogicNodePropertiesData[i].DeserializeFields(MemberVisibility.Public) as LogicNodeProperties;
                    } catch (Exception e) {
                        m_LogicNodeProperties[i] = new LogicNodeProperties();
                        Debug.LogError($"Error: Unable to load task editor data at index {i} due to exception:\n{e}");
                    }
                }
            } else {
                m_LogicNodeProperties = null;
            }
            if (m_EventNodePropertiesData != null && m_EventNodePropertiesData.Length > 0) {
                m_EventNodeProperties = new NodeProperties[m_EventNodePropertiesData.Length];
                for (int i = 0; i < m_EventNodePropertiesData.Length; ++i) {
                    m_EventNodeProperties[i] = m_EventNodePropertiesData[i].DeserializeFields(MemberVisibility.Public) as NodeProperties;
                }
            } else {
                m_EventNodeProperties = null;
            }
            if (m_GroupPropertiesData != null && m_GroupPropertiesData.Length > 0) {
                m_GroupProperties = new GroupProperties[m_GroupPropertiesData.Length];
                for (int i = 0; i < m_GroupPropertiesData.Length; ++i) {
                    m_GroupProperties[i] = m_GroupPropertiesData[i].DeserializeFields(MemberVisibility.Public) as GroupProperties;
                }
            } else {
                m_GroupProperties = null;
            }
#endif
            DeserializeSharedVariables(force, sharedVariableOverrides);
            m_VariableByNameMap = PopulateSharedVariablesMapping(graph, canDeepCopyVariables);

            // The disabled node indicies need to be deserialized before the nodes.
            if (m_DisabledEventNodesData != null && m_DisabledEventNodesData.Length > 0 && m_EventTaskData != null) {
                m_DisabledEventNodes = new ushort[m_DisabledEventNodesData.Length];
                var offset = 0;
                for (int i = 0; i < m_DisabledEventNodesData.Length; ++i) {
                    m_DisabledEventNodes[i] = (ushort)m_DisabledEventNodesData[i].DeserializeFields(MemberVisibility.Public);
                    // The node index may no longer be valid.
                    if (m_DisabledEventNodes[i - offset] >= m_EventTaskData.Length) {
                        offset++;
                    }
                }
                if (offset > 0) {
                    Array.Resize(ref m_DisabledEventNodes, m_DisabledEventNodes.Length - offset);
                }
            } else {
                m_DisabledEventNodes = null;
            }
            if (m_DisabledLogicNodesData != null && m_DisabledLogicNodesData.Length > 0 && m_TaskData != null) {
                m_DisabledLogicNodes = new ushort[m_DisabledLogicNodesData.Length];
                var offset = 0;
                for (int i = 0; i < m_DisabledLogicNodesData.Length; ++i) {
                    m_DisabledLogicNodes[i - offset] = (ushort)m_DisabledLogicNodesData[i].DeserializeFields(MemberVisibility.Public);
                    // The node index may no longer be valid.
                    if (m_DisabledLogicNodes[i - offset] >= m_TaskData.Length) {
                        offset++;
                    }
                }
                if (offset > 0) {
                    Array.Resize(ref m_DisabledLogicNodes, m_DisabledLogicNodes.Length - offset);
                }
            } else {
                m_DisabledLogicNodes = null;
            }

            ResizableArray<TaskAssignment> taskReferences = null;
            if (m_SubtreeNodesReference != null) {
                m_SubtreeNodesReference.Clear();
            }
            if (m_TaskData != null && m_TaskData.Length > 0) {
                m_Tasks = new ILogicNode[m_TaskData.Length];
                for (int i = 0; i < m_TaskData.Length; ++i) {
                    try {
                        m_Tasks[i] = m_TaskData[i].DeserializeFields(MemberVisibility.Public, ValidateDeserializedTypeObject, (object fieldInfoObj, object task, object value) =>
                        {
                            return ValidateDeserializedObject(fieldInfoObj, task, value, ref m_VariableByNameMap, ref taskReferences, sharedVariableOverrides);
                        }) as ILogicNode;
                    } catch (Exception e) {
                        Debug.LogError($"Error: Unable to load task {m_TaskData[i].ObjectType} at index {i} due to exception:\n{e}");
                    }

                    // Account for tasks where the object no longer exists.
                    if (m_Tasks[i] == null) {
#if UNITY_EDITOR
                        if (m_LogicNodeProperties[i].Data.IsParent) {
                            m_Tasks[i] = new UnknownParentTaskNode(m_TaskData[i].ObjectType);
                        } else {
                            m_Tasks[i] = new UnknownTaskNode(m_TaskData[i].ObjectType);
                        }
                        m_Tasks[i].Index = (ushort)i;
                        m_Tasks[i].ParentIndex = m_LogicNodeProperties[i].Data.ParentIndex;
                        m_Tasks[i].SiblingIndex = m_LogicNodeProperties[i].Data.SiblingIndex;
#else
                        if (i + 1 < m_Tasks.Length && m_Tasks[i + 1] != null && m_Tasks[i + 1].ParentIndex == i) {
                            m_Tasks[i] = new UnknownParentTaskNode(m_TaskData[i].ObjectType);
                        } else {
                            m_Tasks[i] = new UnknownTaskNode(m_TaskData[i].ObjectType);
                        }
                        m_Tasks[i].Index = (ushort)i;
#endif
                    }

                    // The RuntimeIndex is assigned later when the tree is initialized.
                    m_Tasks[i].RuntimeIndex = ushort.MaxValue;

#if UNITY_EDITOR
                    // Sanity checks.
                    if (m_Tasks[i].Index >= m_TaskData.Length) { m_Tasks[i].Index = (ushort)i; }
                    if (m_Tasks[i].ParentIndex != ushort.MaxValue && m_Tasks[i].ParentIndex >= m_TaskData.Length) { m_Tasks[i].ParentIndex = ushort.MaxValue; }
                    if (m_Tasks[i].SiblingIndex != ushort.MaxValue && m_Tasks[i].SiblingIndex >= m_TaskData.Length) { m_Tasks[i].SiblingIndex = ushort.MaxValue; }
#endif

                    if (injectSubtrees) {
                        // If the previous task is a parent the current task has to be a child otherwise the tree is in an error state. The error will also occur
                        // if there is only one task and that task is a parent task.
                        if ((m_Tasks[i].ParentIndex != ushort.MaxValue && (i > 0 && m_Tasks[i - 1] is IParentNode && m_Tasks[i].ParentIndex != m_Tasks[i - 1].Index)) || (m_Tasks[i] is IParentNode && i + 1 == m_Tasks.Length)) {
                            Debug.LogError($"Error: {graph} contains the parent task {m_Tasks[i].GetType().Name} which does not have any children. All parent tasks must contain at least one child.", graph.Parent);
                            errorState = true;
                            continue;
                        }

                        // Subtrees will be evaluated after all tasks are assigned.
                        if (m_Tasks[i] is ISubtreeReference subtreeReference) {
                            // Subtrees can be nested.
                            subtreeReference.EvaluateSubtrees(graphComponent);
                            var subtrees = subtreeReference.Subtrees;
                            if (subtrees != null) {
                                // The parent must be able to accept the number of subtrees that there are.
                                var parentIndex = m_Tasks[i].ParentIndex;
                                IParentNode parentNode = null;
                                if (parentIndex != ushort.MaxValue) {
                                    parentNode = m_Tasks[parentIndex] as IParentNode;
                                }

                                if ((parentNode == null && subtrees.Length > 1) || (parentNode != null && subtrees.Length > parentNode.MaxChildCount)) {
                                    Debug.LogError($"Error: {graph} on object {graph.Parent} contains multiple subtrees as the starting task or as a child of a parent task which cannot contain so many children (such as a decorator).", graph.Parent);
                                    errorState = true;
                                    continue;
                                }

                                var deserializedNodes = new ILogicNode[subtrees.Length][];
                                for (int j = 0; j < subtrees.Length; ++j) {
                                    if (subtrees[j] == null) {
                                        continue;
                                    }
                                    if (!subtrees[j].Deserialize(graphComponent, force, true, true, subtreeReference.SharedVariableOverrides)) {
                                        errorState = true;
                                        break;
                                    };
                                    // Keep a reference to the deserialized nodes. This will ensure they are unique and do not get overwritten.
                                    deserializedNodes[j] = subtrees[j].LogicNodes;

                                    // Add any new subtree variables to the current tree.
                                    if (subtrees[j].SharedVariables != null) {
                                        // In order to reduce allocations the first loop will determine the number of variables that need to be added.
                                        var length = subtrees[j].SharedVariables.Length;
                                        var variableCount = 0;
                                        for (int k = 0; k < length; ++k) {
                                            var subtreeVariable = subtrees[j].SharedVariables[k];
                                            if (GetVariable(graph, subtreeVariable.Name, SharedVariable.SharingScope.Graph) == null) {
                                                variableCount++;
                                            }
                                        }

                                        // And the second loop will actually add the variables.
                                        if (variableCount > 0) {
                                            var insertIndex = 0;
                                            if (m_SharedVariables == null) {
                                                m_SharedVariables = new SharedVariable[variableCount];
                                                m_VariableByNameMap = new Dictionary<VariableAssignment, SharedVariable>();
                                            } else {
                                                insertIndex = m_SharedVariables.Length;
                                                Array.Resize(ref m_SharedVariables, m_SharedVariables.Length + variableCount);
                                            }
                                            for (int k = 0; k < length; ++k) {
                                                var subtreeVariable = subtrees[j].SharedVariables[k];
                                                if (!m_VariableByNameMap.ContainsKey(new VariableAssignment(subtreeVariable.Name, SharedVariable.SharingScope.Graph))) {
                                                    m_SharedVariables[insertIndex] = subtreeVariable;
                                                    m_VariableByNameMap.Add(new VariableAssignment(subtreeVariable.Name, SharedVariable.SharingScope.Graph), subtreeVariable);
                                                    insertIndex++;
                                                }
                                            }
                                        }
                                    }
                                }

                                // Do not add the subtree if it causes an error.
                                if (!errorState) {
                                    if (m_SubtreeNodesReference == null) { m_SubtreeNodesReference = new ResizableArray<SubtreeNodesReference>(); }
                                    m_SubtreeNodesReference.Add(new SubtreeNodesReference()
                                    {
                                        SubtreeReference = subtreeReference,
                                        NodeIndex = (ushort)i,
                                        Subtrees = subtrees,
                                        Nodes = deserializedNodes
                                    });
                                }
                            }
                        }
                    }
                }
            } else {
                m_Tasks = null;
            }

            // Subtrees should be injected into the tree.
            InjectSubtrees();

            // Add the event tasks after the subtrees have been injected to ensure the connected index is correct.
            if (m_EventTaskData != null && m_EventTaskData.Length > 0) {
                m_EventTasks = new IEventNode[m_EventTaskData.Length];
                for (int i = 0; i < m_EventTaskData.Length; ++i) {
                    m_EventTasks[i] = m_EventTaskData[i].DeserializeFields(MemberVisibility.Public, ValidateDeserializedTypeObject, (object fieldInfoObj, object task, object value) =>
                    {
                        return ValidateDeserializedObject(fieldInfoObj, task, value, ref m_VariableByNameMap, ref taskReferences);
                    }) as IEventNode;

                    if (m_SubtreeNodesReference != null) {
                        // A subtree may have injected nodes before the originally connected index. Modify the index to match the injection.
                        var offset = 0;
                        for (int j = 0; j < m_SubtreeNodesReference.Count; ++j) {
                            if (m_SubtreeNodesReference[j].NodeIndex >= m_EventTasks[i].ConnectedIndex) {
                                break;
                            }
                            offset += m_SubtreeNodesReference[j].NodeCount - 1;
                        }
                        if (offset != 0) {
                            m_EventTasks[i].ConnectedIndex += (ushort)offset;
                        }
                    }

                    if (m_EventTasks[i] == null) {
                        m_EventTasks[i] = new UnknownEventTask();
                    }
                }
            } else {
                m_EventTasks = null;
            }

            // After the tree has been deserialized the task references need to be assigned.
            AssignTaskReferences(m_Tasks, taskReferences);

            m_Deserializing = false;

            return !errorState;
        }

        /// <summary>
        /// Validates the object type when deserializing.
        /// </summary>
        /// <param name="type">The type of object that should be validated.</param>
        /// <param name="field">The field that contains the object.</param>
        /// <returns>The validated type.</returns>
        public static Type ValidateDeserializedTypeObject(Type type, FieldInfo field)
        {
            if (typeof(IList).IsAssignableFrom(type)) {
                var elementType = Serializer.GetElementType(type);
                if (typeof(ILogicNode).IsAssignableFrom(elementType) && (field == null || field.GetCustomAttribute<InspectNodeAttribute>() == null)) {
                    return typeof(ushort[]);
                }
            } else if (typeof(ILogicNode).IsAssignableFrom(type) && (field == null || field.GetCustomAttribute<InspectNodeAttribute>() == null)) {
                return typeof(ushort);
            }
            return type;
        }

        /// <summary>
        /// Validates the object when deserializing.
        /// </summary>
        /// <param name="fieldInfoObj">The FieldInfo that is being deserialized.</param>
        /// <param name="target">The object being deserialized.</param>
        /// <param name="value">The value of the field.</param>
        /// <param name="variableByNameMap">A reference to the map between the VariableAssignment and SharedVariable.</param>
        /// <param name="taskReferences">A reference to the list of task references that need to be resolved later.</param>
        /// <param name="sharedVariableOverrides">A list of SharedVariables that should override the current SharedVariable value.</param>
        /// <returns>The validated object.</returns>
        public static object ValidateDeserializedObject(object fieldInfoObj, object target, object value, ref Dictionary<VariableAssignment, SharedVariable> variableByNameMap,
                                    ref ResizableArray<TaskAssignment> taskReferences, SharedVariableOverride[] sharedVariableOverrides = null)
        {
            var fieldInfo = fieldInfoObj as FieldInfo;
            if (fieldInfo == null) {
                return value;
            }

            var type = fieldInfo.FieldType;
            if (value == null) {
                // A SharedVariable object should always exist.
                if (!type.IsAbstract && typeof(SharedVariable).IsAssignableFrom(type)) {
                    return Activator.CreateInstance(type);
                }
                return null;
            }

            if (typeof(IList).IsAssignableFrom(type)) {
                var elementType = Serializer.GetElementType(type);
                if (typeof(ILogicNode).IsAssignableFrom(elementType) && fieldInfo.GetCustomAttribute<InspectNodeAttribute>() == null) {
                    // The task reference will be assigned after all of the tasks have been deserialized.
                    if (taskReferences == null) { taskReferences = new ResizableArray<TaskAssignment>(); }
                    taskReferences.Add(new TaskAssignment() { Field = fieldInfo, Target = target, Value = value });
                } else if (typeof(SharedVariable).IsAssignableFrom(elementType)) {
                    var listValue = value as IList;
                    if (listValue != null) {
                        for (int i = 0; i < listValue.Count; ++i) {
                            var sharedVariableElement = listValue[i] as SharedVariable;
                            if (variableByNameMap != null && sharedVariableElement != null && !string.IsNullOrEmpty(sharedVariableElement.Name)) {
                                if (variableByNameMap.TryGetValue(new VariableAssignment(sharedVariableElement.Name, sharedVariableElement.Scope), out var mappedSharedVariable)) {
                                    if (Application.isPlaying && sharedVariableElement.Scope == SharedVariable.SharingScope.Dynamic && sharedVariableElement.GetType() != mappedSharedVariable.GetType()) {
                                        Debug.LogError($"Error: The dynamic variables with name {sharedVariableElement.Name} have different types. All dynamic variables must have the same type.");
                                        listValue[i] = sharedVariableElement;
                                    } else {
                                        listValue[i] = GetOverrideVariable(sharedVariableOverrides, mappedSharedVariable, false);
                                    }
                                } else if (sharedVariableElement.Scope == SharedVariable.SharingScope.Dynamic) {
                                    // New dynamic variables should have the default value.
                                    var sharedVariableValueType = sharedVariableElement.GetType().GetGenericArguments()[0];
                                    if (sharedVariableValueType.IsValueType) {
                                        sharedVariableElement.SetValue(Activator.CreateInstance(sharedVariableValueType));
                                    } else {
                                        sharedVariableElement.SetValue(null);
                                    }

                                    // Dynamic variables are created when the task is deserialized. The variable needs to be added to the mapping so it can be reused.
                                    variableByNameMap.Add(new VariableAssignment(sharedVariableElement.Name, sharedVariableElement.Scope), sharedVariableElement);
                                    listValue[i] = sharedVariableElement;
                                }
                            }

                        }
                        return listValue;
                    }
                }
            } else if (typeof(ILogicNode).IsAssignableFrom(type) && fieldInfo.GetCustomAttribute<InspectNodeAttribute>() == null) {
                // The task reference will be assigned after all of the tasks have been deserialized.
                if (taskReferences == null) { taskReferences = new ResizableArray<TaskAssignment>(); }
                taskReferences.Add(new TaskAssignment() { Field = fieldInfo, Target = target, Value = value });
            } else if (typeof(SharedVariable).IsAssignableFrom(type)) {
                var sharedVariable = value as SharedVariable;
                if (variableByNameMap != null && sharedVariable != null && !string.IsNullOrEmpty(sharedVariable.Name)) {
                    if (variableByNameMap.TryGetValue(new VariableAssignment(sharedVariable.Name, sharedVariable.Scope), out var mappedSharedVariable)) {
                        if (Application.isPlaying && sharedVariable.Scope == SharedVariable.SharingScope.Dynamic && sharedVariable.GetType() != mappedSharedVariable.GetType()) {
                            Debug.LogError($"Error: The dynamic variables with name {sharedVariable.Name} have different types. Dynamic variables with the same name must have the same type.");
                            return sharedVariable;
                        }
                        return GetOverrideVariable(sharedVariableOverrides, mappedSharedVariable, false);
                    } else if (Application.isPlaying && sharedVariable.Scope == SharedVariable.SharingScope.Dynamic) {
                        // New dynamic variables should have the default value.
                        var sharedVariableValueType = sharedVariable.GetType().GetGenericArguments()[0];
                        if (sharedVariableValueType.IsValueType) {
                            sharedVariable.SetValue(Activator.CreateInstance(sharedVariableValueType));
                        } else {
                            sharedVariable.SetValue(null);
                        }

                        // Dynamic variables are created when the task is deserialized. The variable needs to be added to the mapping so it can be reused.
                        variableByNameMap.Add(new VariableAssignment(sharedVariable.Name, sharedVariable.Scope), sharedVariable);
                        return sharedVariable;
                    }
                }
            }

            return value;
        }

        /// <summary>
        /// Deserializes the SharedVariables. This allows the SharedVariables to be deserialized independently.
        /// </summary>
        /// <param name="force">Should the variables be forced deserialized?</param>
        /// <param name="sharedVariableOverrides">A list of SharedVariables that should override the current SharedVariable value.</param>
        /// <returns>True if the SharedVariables were deserialized.</returns>
        public bool DeserializeSharedVariables(bool force, SharedVariableOverride[] sharedVariableOverrides = null)
        {
            // No need to deserialize if the data is already deserialized.
            if (m_SharedVariables != null && !force) {
                return false;
            }

            if (m_SharedVariableData != null && m_SharedVariableData.Length > 0) {
                m_SharedVariables = new SharedVariable[m_SharedVariableData.Length];
                for (int i = 0; i < m_SharedVariableData.Length; ++i) {
                    try {
                        m_SharedVariables[i] = m_SharedVariableData[i].DeserializeFields(MemberVisibility.Public) as SharedVariable;
                    } catch (Exception e) {
                        Debug.LogError($"Error: Unable to load variable {m_SharedVariableData[i].ObjectType} at index {i} due to exception:\n{e}");
                    }

                    if (m_SharedVariables[i] == null) {
                        m_SharedVariables[i] = new UnknownSharedVariable();
                        m_SharedVariables[i].Name = m_SharedVariableData[i].ObjectType + UnityEngine.Random.value;

                        Debug.LogError($"Error: Unable to deserialize SharedVariable of type {m_SharedVariableData[i].ObjectType}.");
                        continue;
                    }

                    // The override variable can set a value specific for the subtree.
                    if (Application.isPlaying) {
                        m_SharedVariables[i].Initialize();

                        var overrideVariable = GetOverrideVariable(sharedVariableOverrides, m_SharedVariables[i], true);
                        // If the overridden scope is self then only the value should be overridden and not the SharedVariable reference.
                        if (overrideVariable != null && overrideVariable.Scope == SharedVariable.SharingScope.Self) {
                            m_SharedVariables[i].SetValue(overrideVariable.GetValue());
                        }
                    }
                }
            } else {
                m_SharedVariables = null;
            }

            return true;
        }

        /// <summary>
        /// Returns the override SharedVariable from the source SharedVariable.
        /// </summary>
        /// <param name="sharedVariableOverrides">The list of override SharedVariables.</param>
        /// <param name="graphVariable">The variable that should be overridden.</param>
        /// <param name="deserialize">Is the method being called when the variables are being deserialized?</param>
        /// <returns>The override SharedVariable (can be null).</returns>
        private static SharedVariable GetOverrideVariable(SharedVariableOverride[] sharedVariableOverrides, SharedVariable graphVariable, bool deserialize)
        {
            if (sharedVariableOverrides == null) {
                return deserialize ? null : graphVariable;
            }

            for (int i = 0; i < sharedVariableOverrides.Length; ++i) {
                var overrideVariable = sharedVariableOverrides[i].Override;
                // Empty variables indicate that the variable should not be overridden.
                if (overrideVariable == null || overrideVariable.Scope == SharedVariable.SharingScope.Empty) {
                    continue;
                }

                // The override variable should be used if the name and the type matches.
                var sourceVariable = sharedVariableOverrides[i].Source;
                if (sourceVariable.GetType() != graphVariable.GetType() || sourceVariable.Name != graphVariable.Name) {
                    continue;
                }

                // If the scope is self then the graphVariable value should be updated instead of completely replaced.
                if (overrideVariable.Scope == SharedVariable.SharingScope.Self) {
                    graphVariable.SetValue(overrideVariable.GetValue());
                    return graphVariable;
                }

                return overrideVariable;
            }

            return graphVariable;
        }

        /// <summary>
        /// Internal data structure for referencing a SharedVariable to its name/scope.
        /// </summary>
        public struct VariableAssignment
        {
            [Tooltip("The name of the SharedVariable.")]
            public string Name;
            [Tooltip("The scope of the SharedVariable.")]
            public SharedVariable.SharingScope Scope;

            /// <summary>
            /// VariableAssignment constructor.
            /// </summary>
            /// <param name="name">The name of the SharedVariable.</param>
            /// <param name="scope">The scope of the SharedVariable.</param>
            public VariableAssignment(string name, SharedVariable.SharingScope scope)
            {
                Name = name;
                Scope = scope;
            }
        }

        /// <summary>
        /// Populates the SharedVariable Mapping at runtime.
        /// </summary>
        /// <param name="graph">The graph that is being deserialized.</param>
        /// <param name="canDeepCopy">Can the SharedVariables be deep copied?</param>
        /// <returns>A reference to the map between the VariableAssignment and SharedVariable.</returns>
        public static Dictionary<VariableAssignment, SharedVariable> PopulateSharedVariablesMapping(IGraph graph, bool canDeepCopy)
        {
            var variableByNameMap = new Dictionary<VariableAssignment, SharedVariable>();
            PopulateSharedVariablesMapping(graph, graph.SharedVariables, SharedVariable.SharingScope.Graph, canDeepCopy, ref variableByNameMap);

            if (graph.Parent is GameObject parentGameObject) {
                var gameObjectSharedVariablesContainer = parentGameObject.GetComponent<GameObjectSharedVariables>();
                if (gameObjectSharedVariablesContainer != null) {
                    gameObjectSharedVariablesContainer.Deserialize(false);
                    PopulateSharedVariablesMapping(graph, gameObjectSharedVariablesContainer.SharedVariables, SharedVariable.SharingScope.GameObject, canDeepCopy, ref variableByNameMap);
                }
            }

            var sceneSharedVariablesContainer = SceneSharedVariables.Instance;
            if (sceneSharedVariablesContainer != null) {
                sceneSharedVariablesContainer.Deserialize(false);
                PopulateSharedVariablesMapping(graph, sceneSharedVariablesContainer.SharedVariables, SharedVariable.SharingScope.Scene, canDeepCopy, ref variableByNameMap);
            }

            var projectSharedVariablesContainer = ProjectSharedVariables.Instance;
            if (projectSharedVariablesContainer != null) {
                projectSharedVariablesContainer.Deserialize(false);
                PopulateSharedVariablesMapping(graph, projectSharedVariablesContainer.SharedVariables, SharedVariable.SharingScope.Project, canDeepCopy, ref variableByNameMap);
            }
            return variableByNameMap;
        }

        /// <summary>
        /// Populates the name variables mapping with the specified SharedVariables.
        /// </summary>
        /// <param name="graph">The graph that is being deserialized.</param>
        /// <param name="sharedVariables">The SharedVariables that should be populated.</param>
        /// <param name="scope">The scope of SharedVariables.</param>
        /// <param name="canDeepCopy">Can the SharedVariables be deep copied?</param>
        /// <param name="variableByNameMap">A reference to the map between the VariableAssignment and SharedVariable.</param>
        private static void PopulateSharedVariablesMapping(IGraph graph, SharedVariable[] sharedVariables, SharedVariable.SharingScope scope, bool canDeepCopy, ref Dictionary<VariableAssignment, SharedVariable> variableByNameMap)
        {
            if (sharedVariables == null) {
                return;
            }

            for (int i = 0; i < sharedVariables.Length; ++i) {
                if (sharedVariables[i] == null) {
                    continue;
                }
                if (variableByNameMap.ContainsKey(new VariableAssignment(sharedVariables[i].Name, scope))) {
#if UNITY_EDITOR
                    Debug.LogWarning("Warning: Multiple SharedVariables with the same name have been added. Please email support@opsive.com with the steps to reproduce this warning. Thank you.");
#endif
                    continue;
                }
                var deepCopy = canDeepCopy && graph is Subtree && scope == SharedVariable.SharingScope.Graph; // Deep copy variables so the instance is not bound to the subtree.
                variableByNameMap.Add(new VariableAssignment(sharedVariables[i].Name, scope), deepCopy ? CopyUtility.DeepCopy(sharedVariables[i]) as SharedVariable : sharedVariables[i]);
            }
        }

        /// <summary>
        /// When the behavior tree loads not all tasks will be deserialized instantly. TaskA may reference TaskB but TaskB hasn't
        /// been deserialized yet. The TaskAssignment data structure will store all of the references that need to be restored after
        /// the behavior tree has fully been deserialized.
        /// </summary>
        /// <param name="tasks">The tasks that belong to the graph.</param>
        /// <param name="taskReferences">The tasks that should be referenced.</param>
        public static void AssignTaskReferences(ILogicNode[] tasks, ResizableArray<TaskAssignment> taskReferences)
        {
            if (taskReferences == null) {
                return;
            }

            for (int i = 0; i < taskReferences.Count; ++i) {
                var taskReference = taskReferences[i];
                var fieldType = taskReference.Field.FieldType;
                object value = null;

                // The field can be a list or single value.
                if (typeof(IList).IsAssignableFrom(fieldType)) {
                    var elements = (IList)taskReferences[i].Value;
                    if (fieldType.IsArray) {
                        // The field type is an array. Create a new array with all of the task instances.
                        var array = Array.CreateInstance(Serializer.GetElementType(fieldType), elements.Count) as ILogicNode[];
                        for (int j = 0; j < array.Length; ++j) {
                            var index = (ushort)elements[j];
                            if (index < tasks.Length) {
                                array[j] = tasks[index];
                            }
                        }
                        value = array;
                    } else {
                        // The field type is a list. Create a new list with all of the task instances.
                        IList taskList;
                        if (fieldType.IsGenericType) {
                            taskList = Activator.CreateInstance(typeof(List<>).MakeGenericType(Serializer.GetElementType(fieldType))) as IList;
                        } else {
                            taskList = Activator.CreateInstance(fieldType) as IList;
                        }

                        for (int j = 0; j < elements.Count; ++j) {
                            var index = (ushort)elements[j];
                            if (index < tasks.Length) {
                                taskList.Add(tasks[index]);
                            }
                        }
                        value = taskList;
                    }
                } else { // Single ILogicNode value.
                    var index = (ushort)taskReference.Value;
                    if (index < tasks.Length) {
                        value = tasks[index];
                    }
                }
                if (value != null) {
                    taskReference.Field.SetValue(taskReference.Target, value);
                }
            }
        }

        /// <summary>
        /// Contains a reference to the subtree index and nodes.
        /// </summary>
        internal struct SubtreeNodesReference
        {
            [Tooltip("The ISubtreeReference.")]
            public ISubtreeReference SubtreeReference;
            [Tooltip("The index of the ISubtreeReference.")]
            public ushort NodeIndex;
            [Tooltip("The total number of nodes contained within the ISubtreeReference.")]
            public ushort NodeCount;
            [Tooltip("A reference to the subtrees that are loaded.")]
            public Subtree[] Subtrees;
            [Tooltip("The deserialized nodes.")]
            public ILogicNode[][] Nodes;
        }

        /// <summary>
        /// Data structure which contains the properties for a subtree that will be injected.
        /// </summary>
        private struct SubtreeAssignment
        {
            [Tooltip("The index of the SubtreeNodesReference element.")]
            public int ReferenceIndex;
            [Tooltip("The index of the ISubtreeReference task.")]
            public ushort NodeIndex;
            [Tooltip("The index of the Subtree.")]
            public int SubtreeIndex;
            [Tooltip("The subtree that the task references.")]
            public Subtree Subtree;
            [Tooltip("The offset of the index. This will change as subtrees are added.")]
            public ushort IndexOffset;
            [Tooltip("The original parent index of the ISubtreeReference task.")]
            public ushort ParentIndex;
            [Tooltip("The original sibling index of the ISubtreeReference task.")]
            public ushort SiblingIndex;
            [Tooltip("The number of nodes that are a child of the ISubtreeReference.")]
            public ushort NodeCount;
#if UNITY_EDITOR
            [Tooltip("The position of the ISubtreeReference task.")]
            public Vector2 NodePropertiesPosition;
            [Tooltip("Is the ISubtreeReference task collapsed?")]
            public bool Collapsed;
#endif
        }

        /// <summary>
        /// Injects the subtree into the task list.
        /// </summary>
        private void InjectSubtrees()
        {
            if (m_SubtreeNodesReference == null || m_SubtreeNodesReference.Count == 0) {
                return;
            }

            // The behavior tree must generate a new ID when subtrees are injected.
            m_RuntimeUniqueID = Guid.NewGuid().GetHashCode();

            var taskCount = 0;
            var subtreeReferenceCount = 0;
            var subtreeAssignments = new ResizableArray<SubtreeAssignment>();
            var lastParentIndex = m_Tasks[m_SubtreeNodesReference[0].NodeIndex].ParentIndex;
            var parentIndexOffset = 0;
            for (int i = 0; i < m_SubtreeNodesReference.Count; ++i) {
                var subtreeReference = m_Tasks[m_SubtreeNodesReference[i].NodeIndex] as ISubtreeReference;
                var subtrees = subtreeReference.Subtrees;
                if (subtrees != null) {
                    var indexOffset = (ushort)0; // The index offset is relative to each individual ISubtreeReference task.

                    // The parent index will change based on the number of tasks that have been added.
                    var parentIndex = m_Tasks[m_SubtreeNodesReference[i].NodeIndex].ParentIndex;
                    if (parentIndex != ushort.MaxValue && (parentIndex > lastParentIndex || (i > 0 && lastParentIndex == ushort.MaxValue))) {
                        parentIndexOffset = (ushort)(taskCount - subtreeReferenceCount);
                        lastParentIndex = parentIndex;
                    }

                    // Calculate the parent index offset based on previously injected subtrees
                    for (int j = 0; j < subtrees.Length; ++j) {
                        if (subtrees[j] == null || subtrees[j].LogicNodes == null || subtrees[j].EventNodes == null) {
                            continue;
                        }

                        // The subtree should start from the start node.
                        var startNode = subtrees[j].GetEventNode(typeof(Start)); // Returns (IEventNode, index).
                        if (startNode.Item1 == null || startNode.Item1.ConnectedIndex == ushort.MaxValue || !subtrees[j].IsNodeEnabled(false, startNode.Item2)) {
                            continue;
                        }

                        var firstNode = m_SubtreeNodesReference[i].Nodes[j][startNode.Item1.ConnectedIndex];
                        var subtreeNodeCount = GetChildCount(firstNode, m_SubtreeNodesReference[i].Nodes[j]) + 1; // firstNode should be included in addition to the children.
                        taskCount += subtreeNodeCount;
                        subtreeAssignments.Add(new SubtreeAssignment()
                        {
                            ReferenceIndex = i,
                            NodeIndex = m_SubtreeNodesReference[i].NodeIndex,
                            SubtreeIndex = j,
                            Subtree = subtrees[j],
                            NodeCount = (ushort)subtreeNodeCount,
                            IndexOffset = indexOffset,
                            ParentIndex = (ushort)(parentIndex + parentIndexOffset),
                            SiblingIndex = m_Tasks[m_SubtreeNodesReference[i].NodeIndex].SiblingIndex,
#if UNITY_EDITOR
                            NodePropertiesPosition = m_LogicNodeProperties[m_SubtreeNodesReference[i].NodeIndex].Position,
                            Collapsed = m_LogicNodeProperties[m_SubtreeNodesReference[i].NodeIndex].Collapsed
#endif
                        });
                        indexOffset += (ushort)subtreeNodeCount;
                    }

                    // Update the parent index offset for the next subtree reference
                    if (indexOffset > 0) { // Subtree References may not contain any valid subtrees.
                        subtreeReferenceCount++;
                    }
                    var subtreeNodesReferenceOrig = m_SubtreeNodesReference[i];
                    subtreeNodesReferenceOrig.NodeCount = indexOffset;
                    m_SubtreeNodesReference[i] = subtreeNodesReferenceOrig;
                }
            }

            if (taskCount == 0) {
                return;
            }

            var targetCount = m_Tasks.Length + taskCount - subtreeReferenceCount;
            var originalTaskCount = m_Tasks.Length;
            if (m_Tasks.Length != targetCount) {
                Array.Resize(ref m_Tasks, targetCount);
#if UNITY_EDITOR
                Array.Resize(ref m_LogicNodeProperties, targetCount);
#endif
            }

            // Make space for all of the subtree tasks.
            var addedTasks = 0;
            for (int i = 0; i < subtreeAssignments.Count; ++i) {
                var subtreeIndex = (ushort)(subtreeAssignments[i].NodeIndex + addedTasks);
                var subtreeTaskCount = subtreeAssignments[i].NodeCount - (subtreeAssignments[i].IndexOffset == 0 ? 1 : 0);
                if (subtreeTaskCount > 0) { // subtreeTaskCount will be zero if a single task replaces the reference task.
                    for (int j = originalTaskCount - 1 + addedTasks; j > subtreeIndex; --j) {
                        var node = m_Tasks[j];
                        node.Index += (ushort)subtreeTaskCount;
                        if (node.ParentIndex > subtreeIndex && node.ParentIndex != ushort.MaxValue) {
                            node.ParentIndex += (ushort)subtreeTaskCount;
                        }
                        if (node.SiblingIndex > subtreeIndex && node.SiblingIndex != ushort.MaxValue) {
                            node.SiblingIndex += (ushort)subtreeTaskCount;
                        }
                        m_Tasks[j + subtreeTaskCount] = node;
                        m_Tasks[j] = null;
#if UNITY_EDITOR
                        m_LogicNodeProperties[j + subtreeTaskCount] = m_LogicNodeProperties[j];
#endif
                    }

                    // The parents need to adjust their sibling index offsets for the newly added nodes. This should only be done with an index offset of 0
                    // as grouped subtrees have the same parents.
                    if (subtreeAssignments[i].IndexOffset == 0) {
                        var parentIndex = m_Tasks[subtreeIndex].ParentIndex;
                        while (parentIndex != ushort.MaxValue) {
                            var parentNode = m_Tasks[parentIndex];
                            if (parentNode.SiblingIndex != ushort.MaxValue) {
                                parentNode.SiblingIndex += (ushort)subtreeTaskCount;
                                m_Tasks[parentIndex] = parentNode;
                            }
                            parentIndex = parentNode.ParentIndex;
                        }
                    }

                    // Any disabled nodes after the insertion needs to shift.
                    var lastDisabledNodeIndex = 0;
                    if (m_DisabledLogicNodes != null) {
                        for (int j = 0; j < m_DisabledLogicNodes.Length; ++j) {
                            if (m_DisabledLogicNodes[j] > subtreeIndex) {
                                m_DisabledLogicNodes[j] += (ushort)subtreeTaskCount;
                            } else { // Remember the last index that was greater than the subtree index so any disabled subtree nodes can be inserted.
                                lastDisabledNodeIndex = j + 1;
                            }
                        }
                    }

                    // If the parent reference task is disabled then all subtree nodes should be disabled.
                    var subtreeDisabledLogicNodes = subtreeAssignments[i].Subtree.DisabledLogicNodes;
                    if (!IsNodeEnabled(true, m_SubtreeNodesReference[subtreeAssignments[i].ReferenceIndex].NodeIndex)) {
                        subtreeDisabledLogicNodes = new ushort[subtreeAssignments[i].NodeCount];
                        for (ushort j = 0; j < subtreeDisabledLogicNodes.Length; ++j) {
                            subtreeDisabledLogicNodes[j] = j;
                        }
                    }

                    // The subtree may have disabled tasks.
                    if (subtreeDisabledLogicNodes != null && subtreeDisabledLogicNodes.Length > 0) {
                        var subtreeDisabledLength = subtreeDisabledLogicNodes.Length;
                        // Ensure all of the disabled logic nodes have been transferred.
                        for (int j = subtreeDisabledLength - 1; j >= 0; --j) {
                            if (subtreeDisabledLogicNodes[j] > subtreeTaskCount) {
                                subtreeDisabledLength--;
                            }
                        }

                        if (subtreeDisabledLength > 0) {
                            if (m_DisabledLogicNodes == null) {
                                m_DisabledLogicNodes = new ushort[subtreeDisabledLength];
                            } else {
                                Array.Resize(ref m_DisabledLogicNodes, m_DisabledLogicNodes.Length + subtreeDisabledLength);
                            }
                            var originalLength = m_DisabledLogicNodes.Length - subtreeDisabledLength;
                            for (int j = lastDisabledNodeIndex; j < originalLength; ++j) {
                                m_DisabledLogicNodes[j + subtreeDisabledLength] = m_DisabledLogicNodes[j];
                            }
                            for (int j = 0; j < subtreeDisabledLength; ++j) {
                                if (subtreeDisabledLogicNodes[j] > subtreeTaskCount) {
                                    continue;
                                }
                                m_DisabledLogicNodes[lastDisabledNodeIndex + j] = (ushort)(subtreeIndex + subtreeDisabledLogicNodes[j]);
                            }
                        }
                    }
                }
                // Tasks were added to the tree. Update the tree to the correct indicies.
                var subtreeAssignment = subtreeAssignments[i];
                subtreeAssignment.IndexOffset = (ushort)(addedTasks + (subtreeAssignments[i].IndexOffset == 0 ? 0 : 1));
                subtreeAssignments[i] = subtreeAssignment;

                addedTasks += subtreeTaskCount;
            }

            // Populate the tasks with the subtree.
            for (int i = 0; i < subtreeAssignments.Count; ++i) {
                var subtreeIndex = (ushort)(subtreeAssignments[i].NodeIndex + subtreeAssignments[i].IndexOffset);
                var subtreeParentIndex = subtreeAssignments[i].ParentIndex;
#if UNITY_EDITOR
                var positionOffset = Vector2.zero;
#endif
                for (int j = 0; j < subtreeAssignments[i].NodeCount; ++j) {
                    var origNode = m_SubtreeNodesReference[subtreeAssignments[i].ReferenceIndex].Nodes[subtreeAssignments[i].SubtreeIndex][j];
                    // The node needs to be copied to prevent the same node from being used in multiple trees.
                    var node = CopyUtility.DeepCopy(m_SubtreeNodesReference[subtreeAssignments[i].ReferenceIndex].Nodes[subtreeAssignments[i].SubtreeIndex][j]) as ILogicNode;
                    node.Index = (ushort)(subtreeIndex + j);
                    node.RuntimeIndex = ushort.MaxValue;
                    if (j == 0) {
                        node.ParentIndex = subtreeParentIndex;
                        subtreeParentIndex = node.Index; // The subsequent subtree tasks should use the first subtree task as the parent reference.
                        node.SiblingIndex = subtreeAssignments[i].SiblingIndex != ushort.MaxValue ? (ushort)(subtreeIndex + subtreeAssignments[i].NodeCount) : ushort.MaxValue;
                    } else {
                        // Adjust the subsequent subtree tasks by the location of the insertion.
                        node.ParentIndex += subtreeParentIndex;
                        if (node.SiblingIndex != ushort.MaxValue) {
                            node.SiblingIndex += subtreeIndex;
                        }
                    }
                    m_Tasks[subtreeIndex + j] = node;
#if UNITY_EDITOR
                    var nodeProperties = CopyUtility.DeepCopy(subtreeAssignments[i].Subtree.LogicNodeProperties[j]) as LogicNodeProperties;
                    nodeProperties.GuidString = Guid.NewGuid().ToString();
                    if (j == 0) {
                        // Keep the tasks in the same relative position as the subtree reference.
                        positionOffset = subtreeAssignments[i].NodePropertiesPosition - subtreeAssignments[i].Subtree.LogicNodeProperties[j].Position;
                    } else {
                        // Apply a small offset for stacked subtrees so they are not directly overlapping.
                        positionOffset += new Vector2(2, 2);
                    }
                    nodeProperties.Position += positionOffset;
                    nodeProperties.Collapsed = subtreeAssignments[i].Collapsed;
                    m_LogicNodeProperties[subtreeIndex + j] = nodeProperties;
#endif
                }
            }
        }

        /// <summary>
        /// Returns the Node of the specified type.
        /// </summary>
        /// <param name="type">The type of Node that should be retrieved.</typeparam>
        /// <returns>The Node of the specified type (can be null).</returns>
        public ILogicNode GetNode(Type type)
        {
            if (m_Tasks == null) {
                return null;
            }

            for (int i = 0; i < m_Tasks.Length; ++i) {
                if (m_Tasks[i].GetType() == type) {
                    return m_Tasks[i];
                }
            }
            return null;
        }

        /// <summary>
        /// Returns the event node of the specified type.
        /// </summary>
        /// <param name="type">The type of EventNode that should be retrieved.</typeparam>
        /// <returns>The EventNode of the specified type (can be null). If the node is found the index will also be returned.</returns>
        public (IEventNode, ushort) GetEventNode(Type type)
        {
            if (m_EventTasks == null) {
                return (null, ushort.MaxValue);
            }

            for (ushort i = 0; i < m_EventTasks.Length; ++i) {
                if (m_EventTasks[i].GetType() == type) {
                    return (m_EventTasks[i], i);
                }
            }
            return (null, ushort.MaxValue);
        }

        /// <summary>
        /// Returns the total number of children belonging to the specified node.
        /// </summary>
        /// <param name="node">The node to retrieve the child count of.</param>
        /// <param name="nodes">All of the nodes that belong to the graph.</param>
        /// <returns>The total number of children belonging to the specified node.</returns>
        public int GetChildCount(ILogicNode node, ILogicNode[] nodes)
        {
            if (node.SiblingIndex != ushort.MaxValue) {
                return node.SiblingIndex - node.Index - 1;
            }

            if (node.Index + 1 == nodes.Length) {
                return 0;
            }

            var child = nodes[node.Index + 1];
            if (child.ParentIndex != node.Index) {
                return 0;
            }

            // Determine the child count based off of the sibling index.
            while (child.SiblingIndex != ushort.MaxValue) {
                child = nodes[child.SiblingIndex];
            }

            return child.Index - node.Index + GetChildCount(child, nodes);
        }

        /// <summary>
        /// Reevaluates the SubtreeReferences by calling the EvaluateSubtrees method.
        /// </summary>
        /// <param name="graphComponent">The component that the graph is being deserialized from.</param>
        /// <param name="graph">The graph that is being reevaluated.</param>
        /// <param name="onBeforeReevaluationSwap">Action that should be done before the tasks are swapped.</param>
        /// <returns>True if the subtree was reevaluated.</returns>
        public bool ReevaluateSubtreeReferences(IGraphComponent graphComponent, IGraph graph, Action onBeforeReevaluationSwap)
        {
            // The tree must contain tasks.
            if (!Application.isPlaying || m_Tasks == null || m_Tasks.Length == 0) {
                return false;
            }

            // Subtree references must exist.
            if (m_SubtreeNodesReference == null || m_SubtreeNodesReference.Count == 0) {
                return false;
            }

            if (onBeforeReevaluationSwap != null) {
                onBeforeReevaluationSwap();
            }

            // Find the new reevaluated nodes.
            for (int i = m_SubtreeNodesReference.Count - 1; i >= 0; --i) {
                var subtreeNodesReference = m_SubtreeNodesReference[i];
                var subtreeReference = m_SubtreeNodesReference[i].SubtreeReference;
                subtreeReference.EvaluateSubtrees(graphComponent);
                var reevaluatedSubtrees = subtreeReference.Subtrees;
                ILogicNode[][] reevaluatedNodes;
                if (reevaluatedSubtrees == null) {
                    continue;
                }

                // The parent must be able to accept the number of subtrees that there are.
                var parentIndex = m_Tasks[m_SubtreeNodesReference[i].NodeIndex].ParentIndex;
                IParentNode parentNode = null;
                if (parentIndex != ushort.MaxValue) {
                    parentNode = m_Tasks[parentIndex] as IParentNode;
                }

                if ((parentNode == null && reevaluatedSubtrees.Length > 1) || (parentNode != null && reevaluatedSubtrees.Length > parentNode.MaxChildCount)) {
                    Debug.LogError($"Error: the reevaluated graph contains multiple subtrees as the starting task or as a child of a parent task which cannot contain so many children (such as a decorator).");
                    continue;
                }

                reevaluatedNodes = new ILogicNode[reevaluatedSubtrees.Length][];
                var errorState = false;
                for (int j = 0; j < reevaluatedSubtrees.Length; ++j) {
                    if (reevaluatedSubtrees[j] == null) {
                        continue;
                    }
                    if (!reevaluatedSubtrees[j].Deserialize(graphComponent, true, true, true, subtreeReference.SharedVariableOverrides)) {
                        errorState = true;
                        break;
                    };
                    // Keep a reference to the deserialized nodes. This will ensure they are unique and do not get overwritten.
                    reevaluatedNodes[j] = reevaluatedSubtrees[j].LogicNodes;
                }
                if (errorState) {
                    continue;
                }

                // The subtree index will be offsetted from the original index value if there are multiple subtree references.
                var nodeOffset = 0;
                for (int j = i - 1; j >= 0; --j) {
                    nodeOffset += m_SubtreeNodesReference[j].NodeCount - 1;
                }

                // All of the reevaluated nodes have been determined. Remove the old subtree nodes.
                var nodeCount = m_SubtreeNodesReference[i].NodeCount;

                // Replace the first node with the subtree reference, and remove the rest of the added nodes.
                m_Tasks[m_SubtreeNodesReference[i].NodeIndex + nodeOffset] = m_SubtreeNodesReference[i].SubtreeReference as ILogicNode;
                for (int j = m_SubtreeNodesReference[i].NodeIndex + nodeOffset + 1; j < m_Tasks.Length - nodeCount + 1; ++j) {
                    m_Tasks[j] = m_Tasks[j + nodeCount - 1];
                    m_Tasks[j].Index = (ushort)j;
                    if (m_Tasks[j].ParentIndex != ushort.MaxValue && m_Tasks[j].ParentIndex > m_SubtreeNodesReference[i].NodeIndex + nodeOffset) {
                        m_Tasks[j].ParentIndex -= (ushort)(nodeCount - 1);
                    }
                    if (m_Tasks[j].SiblingIndex != ushort.MaxValue && m_Tasks[j].SiblingIndex > m_SubtreeNodesReference[i].NodeIndex + nodeOffset) {
                        m_Tasks[j].SiblingIndex -= (ushort)(nodeCount - 1);
                    }

#if UNITY_EDITOR
                    m_LogicNodeProperties[j] = m_LogicNodeProperties[j + nodeCount - 1];
#endif
                }

                // Restore the original ConnectedIndex value.
                if (m_EventTasks != null) {
                    for (int j = 0; j < m_EventTasks.Length; ++j) {
                        if (m_EventTasks[j].ConnectedIndex > m_SubtreeNodesReference[i].NodeIndex) {
                            m_EventTasks[j].ConnectedIndex -= (ushort)(nodeCount - 1);
                        }
                    }
                }
                Array.Resize(ref m_Tasks, m_Tasks.Length - nodeCount + 1);
#if UNITY_EDITOR
                Array.Resize(ref m_LogicNodeProperties, m_LogicNodeProperties.Length - nodeCount + 1);
#endif

                // Replace the old nodes with the new nodes.
                subtreeNodesReference.Nodes = reevaluatedNodes;
                m_SubtreeNodesReference[i] = subtreeNodesReference;

                // The disabled nodes also need to be removed.
                var subtrees = m_SubtreeNodesReference[i].Subtrees;
                var disabledNodesCount = 0;
                for (int j = 0; j < subtrees.Length; ++j) {
                    if (subtrees[j].DisabledLogicNodes == null || subtrees[j].DisabledLogicNodes.Length == 0) {
                        continue;
                    }
                    disabledNodesCount += subtrees[j].DisabledLogicNodes.Length;
                }
                if (disabledNodesCount > 0) {
                    if (m_DisabledLogicNodes.Length > disabledNodesCount) { // The local tree may not have any disabled nodes.
                        for (int j = 0; j < m_DisabledLogicNodes.Length - disabledNodesCount; ++j) {
                            if (m_DisabledLogicNodes[j] >= m_SubtreeNodesReference[i].NodeIndex + nodeOffset + 1) {
                                m_DisabledLogicNodes[j] = (ushort)(m_DisabledLogicNodes[j + disabledNodesCount] - nodeCount + 1);
                            }
                        }
                    }
                    Array.Resize(ref m_DisabledLogicNodes, m_DisabledLogicNodes.Length - disabledNodesCount);
                }
            }

            // The tasks array has been restored to the original set of nodes with the ISubtreeReference. Inject the new nodes.
            InjectSubtrees();

            // Modify the ConnectedIndex to match the injection.
            if (m_EventTasks != null && m_SubtreeNodesReference != null) {
                for (int i = 0; i < m_EventTasks.Length; ++i) {
                    var offset = 0;
                    for (int j = 0; j < m_SubtreeNodesReference.Count; ++j) {
                        if (m_SubtreeNodesReference[j].NodeIndex >= m_EventTasks[i].ConnectedIndex) {
                            break;
                        }
                        offset += m_SubtreeNodesReference[j].NodeCount - 1;
                    }
                    if (offset != 0) {
                        m_EventTasks[i].ConnectedIndex += (ushort)offset;
                    }
                }
            }

            return true;
        }

        /// <summary>
        /// Returns the SharedVariable with the specified name.
        /// </summary>
        /// <param name="graph">The graph that the data belongs to.</typeparam>
        /// <param name="name">The name of the SharedVariable that should be retrieved.</typeparam>
        /// <param name="scope">The scope of the SharedVariable that should be retrieved.</param>
        /// <returns>The SharedVariable with the specified name (can be null).</returns>
        public SharedVariable GetVariable(IGraph graph, string name, SharedVariable.SharingScope scope)
        {
            if (string.IsNullOrEmpty(name)) {
                return null;
            }

            if (m_VariableByNameMap == null) {
                DeserializeSharedVariables(false, null);
                m_VariableByNameMap = PopulateSharedVariablesMapping(graph, true);
            }

            if (m_VariableByNameMap != null && m_VariableByNameMap.TryGetValue(new VariableAssignment(name, scope), out var variable)) {
                return variable;
            }

            return null;
        }

        /// <summary>
        /// Returns the SharedVariable of the specified type.
        /// </summary>
        /// <param name="graph">The graph that the data belongs to.</typeparam>
        /// <param name="name">The name of the SharedVariable that should be retrieved.</typeparam>
        /// <param name="scope">The scope of the SharedVariable that should be retrieved.</param>
        /// <returns>The SharedVariable with the specified name (can be null).</returns>
        public SharedVariable<T> GetVariable<T>(IGraph graph, string name, SharedVariable.SharingScope scope)
        {
            if (string.IsNullOrEmpty(name)) {
                return null;
            }

            if (m_VariableByNameMap == null) {
                DeserializeSharedVariables(false, null);
                m_VariableByNameMap = PopulateSharedVariablesMapping(graph, true);
            }

            if (m_VariableByNameMap != null && m_VariableByNameMap.TryGetValue(new VariableAssignment(name, scope), out var variable)) {
                return variable as SharedVariable<T>;
            }

            return null;
        }

        /// <summary>
        /// Sets the value of the SharedVariable.
        /// </summary>
        /// <typeparam name="T">The type of SharedVarible.</typeparam>
        /// <param name="graph">The graph that the data belongs to.</typeparam>
        /// <param name="name">The name of the SharedVariable.</param>
        /// <param name="value">The value of the SharedVariable.</param>
        public void SetVariableValue<T>(IGraph graph, string name, T value, SharedVariable.SharingScope scope)
        {
            if (string.IsNullOrEmpty(name)) {
                return;
            }

            if (m_VariableByNameMap == null) {
                DeserializeSharedVariables(false, null);
                m_VariableByNameMap = PopulateSharedVariablesMapping(graph, true);
            }

            if (m_VariableByNameMap == null || !m_VariableByNameMap.TryGetValue(new VariableAssignment(name, scope), out var variable)) {
                return;
            }

            (variable as SharedVariable<T>).Value = value;
        }

        /// <summary>
        /// Overrides the SharedVariable value. The name must match an exsting variable.
        /// </summary>
        /// <param name="graph">The graph that the data belongs to.</typeparam>
        /// <param name="variable">The reference to the SharedVariable.</param>
        internal void OverrideVariableValue(IGraph graph, SharedVariable variable)
        {
            if (string.IsNullOrEmpty(variable.Name)) {
                return;
            }

            DeserializeSharedVariables(false, null);
            var dirty = false;
            if (m_SharedVariables != null) {
                for (int i = 0; i < m_SharedVariables.Length; ++i) {
                    if (m_SharedVariables[i].Name == variable.Name && m_SharedVariables[i].GetType() == variable.GetType()) {
                        m_SharedVariables[i].SetValue(variable.GetValue());
                        dirty = true;
                        break;
                    }
                }
            }

            if (dirty) {
                m_VariableByNameMap = PopulateSharedVariablesMapping(graph, true);
            }
        }

        /// <summary>
        /// Is the node with the specified index enabled?
        /// </summary>
        /// <param name="logicNode">Is the node a LogicNode?</param>
        /// <param name="index">The index of the node.</param>
        /// <returns>True if the node with the specified index is enabled.</returns>
        public bool IsNodeEnabled(bool logicNode, int index)
        {
            if (index == ushort.MaxValue) {
                return true;
            }

            var disabledNodes = logicNode ? m_DisabledLogicNodes : m_DisabledEventNodes;
            if (disabledNodes == null) {
                return true;
            }
            for (int i = 0; i < disabledNodes.Length; ++i) {
                if (disabledNodes[i] == index) {
                    return false;
                }
            }
            return true;
        }
    }
}
#endif