#if GRAPH_DESIGNER
/// ---------------------------------------------
/// Behavior Designer
/// Copyright (c) Opsive. All Rights Reserved.
/// https://www.opsive.com
/// ---------------------------------------------
namespace Opsive.BehaviorDesigner.Runtime.Components
{
    using Opsive.BehaviorDesigner.Runtime.Tasks;
    using System.Runtime.InteropServices;
    using Unity.Collections;
    using Unity.Entities;
    using UnityEngine;

    /// <summary>
    /// The runtime DOTS data associated with a task.
    /// </summary>
    [System.Serializable]
    public struct TaskComponent : IBufferElementData
    {
        [Tooltip("The index of the task within the behavior tree.")]
        public ushort Index;
        [Tooltip("The index of the parent task within the behavior tree.")]
        public ushort ParentIndex;
        //public ushort m_ParentIndex;
        //public ushort ParentIndex { get { return m_ParentIndex; } set { UnityEngine.Debug.Log(Index + " parent: " + value); m_ParentIndex = value; } }
        [Tooltip("The index of the sibling task within the behavior tree.")]
        public ushort SiblingIndex;
        //public ushort m_SiblingIndex;
        //public ushort SiblingIndex { get { return m_SiblingIndex; } set { UnityEngine.Debug.Log(Index + " sibling: " + value); m_SiblingIndex = value; } }
        [Tooltip("The index of the branch the task executes within.")]
        public ushort BranchIndex;
        //public ushort m_BranchIndex;
        //public ushort BranchIndex { get { return m_BranchIndex; } set { UnityEngine.Debug.Log(Index + " branch: " + value); m_BranchIndex = value; } }
        [Tooltip("The component type responsible for indicating that the task is active.")]
        public ComponentType FlagComponentType;
        [Tooltip("Is the task disabled?")]
        [MarshalAs(UnmanagedType.U1)]
        public bool Disabled;
        [Tooltip("The current execution status of the task.")]
        //public TaskStatus Status;
        [SerializeField] private TaskStatus m_Status;
        public TaskStatus Status {
            get => m_Status;
            set {
                m_Status = value;
                CanReevaluate = value != TaskStatus.Inactive;
                //UnityEngine.Debug.Log(string.Format("{0} status: {1}", Index, value));
            }
        }
        [Tooltip("Can the task be reevaluated with conditional aborts?")]
        [MarshalAs(UnmanagedType.U1)]
        public bool CanReevaluate;
        [Tooltip("Is the task being reevaluated with conditional aborts?")]
        [MarshalAs(UnmanagedType.U1)]
        public bool Reevaluate;
        //public bool m_Reevaluate;
        //public bool Reevaluate { get { return m_Reevaluate; } set { UnityEngine.Debug.Log(Index + " reevaluate: " + value + " " + GetHashCode());  m_Reevaluate = value; } }
    }

    /// <summary>
    /// Specifies when the behavior tree should be updated.
    /// </summary>
    public enum UpdateMode
    {
        EveryFrame, // The behavior tree should be updated every frame.
        Manual      // The behavior tree should be updated manually via a user script.
    }

    /// <summary>
    /// Specifies how many tasks should be evaluated. Evaluation will end if all branches return a status of TaskStatus.Running.
    /// </summary>
    public enum EvaluationType : byte
    {
        EntireTree, // Evaluates up to all of the tasks within the tree.
        Count       // Evaluates up to the specified MaxEvaluationCount.
    }

    /// <summary>
    /// Specifies if the tree should be evaluated.
    /// </summary>
    public struct EvaluationComponent32 : IComponentData
    {
        [Tooltip("Specifies how many tasks should be updated during a single tick.")]
        public EvaluationType EvaluationType;
        [Tooltip("The maximum number of tasks that can run if the evaluation type is set to EvaluationType.Count.")]
        public ushort MaxEvaluationCount;
        [Tooltip("A bitmask of the tasks that have been evaluated. For EvaluationType.Count, the last element stores the execution count.")]
        public FixedList32Bytes<ulong> EvaluatedTasks;
    }

    /// <summary>
    /// Specifies if the tree should be evaluated.
    /// </summary>
    public struct EvaluationComponent64 : IComponentData
    {
        [Tooltip("Specifies how many tasks should be updated during a single tick.")]
        public EvaluationType EvaluationType;
        [Tooltip("The maximum number of tasks that can run if the evaluation type is set to EvaluationType.Count.")]
        public ushort MaxEvaluationCount;
        [Tooltip("A bitmask of the tasks that have been evaluated. For EvaluationType.Count, the last element stores the execution count.")]
        public FixedList64Bytes<ulong> EvaluatedTasks;
    }

    /// <summary>
    /// Specifies if the tree should be evaluated.
    /// </summary>
    public struct EvaluationComponent128 : IComponentData
    {
        [Tooltip("Specifies how many tasks should be updated during a single tick.")]
        public EvaluationType EvaluationType;
        [Tooltip("The maximum number of tasks that can run if the evaluation type is set to EvaluationType.Count.")]
        public ushort MaxEvaluationCount;
        [Tooltip("A bitmask of the tasks that have been evaluated. For EvaluationType.Count, the last element stores the execution count.")]
        public FixedList128Bytes<ulong> EvaluatedTasks;
    }

    /// <summary>
    /// Specifies if the tree should be evaluated.
    /// </summary>
    public struct EvaluationComponent512 : IComponentData
    {
        [Tooltip("Specifies how many tasks should be updated during a single tick.")]
        public EvaluationType EvaluationType;
        [Tooltip("The maximum number of tasks that can run if the evaluation type is set to EvaluationType.Count.")]
        public ushort MaxEvaluationCount;
        [Tooltip("A bitmask of the tasks that have been evaluated. For EvaluationType.Count, the last element stores the execution count.")]
        public FixedList512Bytes<ulong> EvaluatedTasks;
    }

    /// <summary>
    /// Specifies if the tree should be evaluated.
    /// </summary>
    public struct EvaluationComponent4096 : IComponentData
    {
        [Tooltip("Specifies how many tasks should be updated during a single tick.")]
        public EvaluationType EvaluationType;
        [Tooltip("The maximum number of tasks that can run if the evaluation type is set to EvaluationType.Count.")]
        public ushort MaxEvaluationCount;
        [Tooltip("A bitmask of the tasks that have been evaluated. For EvaluationType.Count, the last element stores the execution count.")]
        public FixedList4096Bytes<ulong> EvaluatedTasks;
    }

    /// <summary>
    /// Specifies how the branch was interrupted.
    /// </summary>
    public enum InterruptType : byte
    {
        None,               // No interrupt.
        Branch,             // A conditional abort or utility selector triggered the interruption.
        ImmediateSuccess,   // The branch was interrupted with a success status.
        ImmediateFailure,   // The branch was interrupted with a failure status.
    }

    /// <summary>
    /// The runtime DOTS data associated with a branch.
    /// </summary>
    public struct BranchComponent : IBufferElementData
    {
        [Tooltip("The index of the task that is currently active.")]
        public ushort ActiveIndex;
        //public ushort m_ActiveIndex;
        //public ushort ActiveIndex { get { return m_ActiveIndex; } set { Debug.Log(string.Format("Active: {0}", value)); m_ActiveIndex = value; } }
        [Tooltip("The index of the task that should execute next.")]
        public ushort NextIndex;
        //public ushort m_NextIndex;
        //public ushort NextIndex { get { return m_NextIndex; } set { Debug.Log(string.Format("Next: {0}", value)); m_NextIndex = value; } }
        [Tooltip("The index of the last active task.")]
        public ushort LastActiveIndex;
        [Tooltip("The component tag that is active.")]
        public ComponentType ActiveFlagComponentType;
        //public ComponentType m_ActiveFlagComponentType;
        //public ComponentType ActiveFlagComponentType { get { return m_ActiveFlagComponentType; } set { Debug.Log(string.Format("Tag: {0}", value)); m_ActiveFlagComponentType = value; } }
        [Tooltip("Specifies how the branch is interrupted.")]
        public InterruptType InterruptType;
        //public InterruptType m_InterruptType;
        //public InterruptType InterruptType { get { return m_InterruptType; } set { m_InterruptType = value; Debug.Log("Interrupt Type " + value); } }
        [Tooltip("The index of the task that caused an interruption. A value of 0 indicates no interruption.")]
        public ushort InterruptIndex;
        [Tooltip("Specifies if the branch can execute tasks. Set to false when all tasks in the branch have executed this tick.")]
        public bool CanExecute;
        //public bool m_CanExecute;
        //public bool CanExecute { get { return m_CanExecute; } set { m_CanExecute = value; Debug.Log("Can Execute " + value); } }
    }

    /// <summary>
    /// Specifies if the tree can be evaluated.
    /// </summary>
    public struct EvaluateFlag : IComponentData, IEnableableComponent { }

    /// <summary>
    /// Specifies if the tree is enabled.
    /// </summary>
    public struct EnabledFlag : IComponentData, IEnableableComponent { }

    /// <summary>
    /// Flag used to indicate when the branch should be interrupted.
    /// </summary>
    public struct InterruptFlag : IComponentData, IEnableableComponent { }

    /// <summary>
    /// Flag used to indicate that the branch has been interrupted.
    /// </summary>
    public struct InterruptedFlag : IComponentData, IEnableableComponent { }

    /// <summary>
    /// Specifies the reevaluation status of the task.
    /// </summary>
    public enum ReevaluateStatus : byte
    {
        Inactive,   // The task is not being reevaluated.
        Active,     // The task is currently being reevaluated.
        Dirty       // The task was reevaluated and triggered a change.
    }

    /// <summary>
    /// The runtime DOTS data associated with conditional aborts.
    /// </summary>
    public struct ReevaluateTaskComponent : IBufferElementData
    {
        [Tooltip("The index of the task.")]
        public ushort Index;
        [Tooltip("The type of conditional abort.")]
        public ConditionalAbortType AbortType;
        [Tooltip("The lower bound index of the next task if a lower priority abort is specified.")]
        public ushort LowerPriorityLowerIndex;
        [Tooltip("The upper bound index of the next task if a lower priority abort is specified.")]
        public ushort LowerPriorityUpperIndex;
        [Tooltip("The upper bound index of the next task if a self priority abort is specified.")]
        public ushort SelfPriorityUpperIndex;
        [Tooltip("The original status of the task.")]
        public TaskStatus OriginalStatus;
        [Tooltip("The tag specifiying the task should be reevaluated.")]
        public ComponentType ReevaluateFlagComponentType;
        [Tooltip("The current reevaluation status of the task.")]
        public ReevaluateStatus ReevaluateStatus;
    }

    /// <summary>
    /// Runtime representation of IEventNodes that can run its own entity logic.
    /// </summary>
    public interface IEventNodeEntityReceiver
    {
        /// <summary>
        /// Adds the IBufferElementData to the entity.
        /// </summary>
        /// <param name="world">The world that the entity exists in.</param>
        /// <param name="entity">The entity that the IBufferElementData should be assigned to.</param>
        /// <param name="gameObject">The GameObject that the entity is attached to.</param>
        /// <param name="taskOffset">The offset between the connected index and the runtime index.</param>
        void AddBufferElement(World world, Entity entity, GameObject gameObject, ushort taskOffset);

        /// <summary>
        /// Clears the IBufferElementData from the entity.
        /// </summary>
        /// <param name="world">The world that the entity exists in.</param>
        /// <param name="entity">The entity that the IBufferElementData should be cleared from.</param>
        void ClearBufferElement(World world, Entity entity);
    }
}
#endif