#if GRAPH_DESIGNER
using Opsive.BehaviorDesigner.Runtime.Components;
using Opsive.BehaviorDesigner.Runtime.Tasks;
using Opsive.BehaviorDesigner.Runtime.Utility;
using Opsive.GraphDesigner.Runtime;
using Opsive.GraphDesigner.Runtime.Variables.ECS;
using Opsive.Shared.Utility;
using Unity.Burst;
using Unity.Entities;
using UnityEngine;
using System;

namespace Cielonos.MainGame.Characters.AI
{
    [Description("可配置成功/失败策略的高级顺序节点。\n" +
                 "按顺序逐个执行子节点，根据策略决定整体结果。\n" +
                 "OneSuccess：任一子节点 Success 即整体成功。\n" +
                 "AllFailure：单个失败不中止后续子节点，全部失败才整体失败。")]
    [NodeIcon("f612c025389b22640b1b6df88f4502e7", "8a4a401bcfb527a48a08351efaf92e14")]
    [Category("Cielonos")]
    public class AdvancedSequence : ECSCompositeTask<AdvancedSequenceTaskSystem, AdvancedSequenceComponent, AdvancedSequenceFlag>,
        IParentNode, IConditionalAbortParent, IInterruptResponder, ISavableTask, ICloneable
    {
        [Tooltip("AllSuccess：全部子节点成功才整体成功。OneSuccess：任一子节点成功即整体成功。")]
        [SerializeField] private SuccessPolicy m_SuccessPolicy = SuccessPolicy.AllSuccess;

        [Tooltip("OneFailure：任一子节点失败即整体失败。AllFailure：所有子节点失败才整体失败，单个失败不中止后续子节点。")]
        [SerializeField] private FailurePolicy m_FailurePolicy = FailurePolicy.OneFailure;

        [Tooltip("指定子节点条件中断的重新评估方式。")]
        [SerializeField] private ConditionalAbortType m_AbortType;

        private ushort m_ComponentIndex;

        public ConditionalAbortType AbortType { get => m_AbortType; set => m_AbortType = value; }
        public Type InterruptSystemType => typeof(AdvancedSequenceInterruptSystem);

        /// <summary>
        /// Returns a new buffer element for use by the ECS system.
        /// </summary>
        public override AdvancedSequenceComponent GetBufferElement()
        {
            return new AdvancedSequenceComponent
            {
                Index            = RuntimeIndex,
                ActiveChildIndex = 0,
                OneSuccessPolicy = m_SuccessPolicy == SuccessPolicy.OneSuccess,
                AllFailurePolicy = m_FailurePolicy == FailurePolicy.AllFailure,
                AnyChildSucceeded = false,
                AnyChildFailed    = false
            };
        }

        /// <summary>
        /// Adds the IBufferElementData and interrupt components to the entity.
        /// </summary>
        public override int AddBufferElement(World world, Entity entity, ECSVariableRegistry registry, GameObject gameObject)
        {
            m_ComponentIndex = (ushort)base.AddBufferElement(world, entity, registry, gameObject);
            ComponentUtility.AddInterruptComponents(world.EntityManager, entity);
            return m_ComponentIndex;
        }

        /// <summary>
        /// Specifies that no reflection-based save is needed.
        /// </summary>
        public MemberVisibility GetSaveReflectionType(int index) { return MemberVisibility.None; }

        /// <summary>
        /// Saves the current task state.
        /// </summary>
        public object Save(World world, Entity entity)
        {
            var components = world.EntityManager.GetBuffer<AdvancedSequenceComponent>(entity);
            var comp = components[m_ComponentIndex];
            return new object[] { comp.ActiveChildIndex, comp.AnyChildSucceeded, comp.AnyChildFailed };
        }

        /// <summary>
        /// Loads the previous task state.
        /// </summary>
        public void Load(object saveData, World world, Entity entity)
        {
            var arr = (object[])saveData;
            var components = world.EntityManager.GetBuffer<AdvancedSequenceComponent>(entity);
            var comp = components[m_ComponentIndex];
            comp.ActiveChildIndex  = (ushort)arr[0];
            comp.AnyChildSucceeded = (bool)arr[1];
            comp.AnyChildFailed    = (bool)arr[2];
            components[m_ComponentIndex] = comp;
        }

        /// <summary>
        /// Creates a deep clone of the task.
        /// </summary>
        public object Clone()
        {
            var clone = Activator.CreateInstance<AdvancedSequence>();
            clone.Index = Index;
            clone.ParentIndex = ParentIndex;
            clone.SiblingIndex = SiblingIndex;
            clone.Enabled = Enabled;
            clone.AbortType = AbortType;
            return clone;
        }

        /// <summary>
        /// Resets the task fields to their default values.
        /// </summary>
        public override void Reset()
        {
            base.Reset();
            m_SuccessPolicy = SuccessPolicy.AllSuccess;
            m_FailurePolicy = FailurePolicy.OneFailure;
        }
    }

    /// <summary>
    /// ECS buffer element storing the runtime state and policy flags for AdvancedSequence.
    /// </summary>
    public struct AdvancedSequenceComponent : IBufferElementData
    {
        [SerializeField] private ushort m_Index;
        [SerializeField] private ushort m_ActiveChildIndex;
        [SerializeField] private bool   m_OneSuccessPolicy;
        [SerializeField] private bool   m_AllFailurePolicy;
        [SerializeField] private bool   m_AnyChildSucceeded;
        [SerializeField] private bool   m_AnyChildFailed;

        public ushort Index             { get => m_Index;             set => m_Index             = value; }
        public ushort ActiveChildIndex  { get => m_ActiveChildIndex;  set => m_ActiveChildIndex  = value; }
        public bool OneSuccessPolicy    { get => m_OneSuccessPolicy;  set => m_OneSuccessPolicy  = value; }
        public bool AllFailurePolicy    { get => m_AllFailurePolicy;  set => m_AllFailurePolicy  = value; }
        public bool AnyChildSucceeded   { get => m_AnyChildSucceeded; set => m_AnyChildSucceeded = value; }
        public bool AnyChildFailed      { get => m_AnyChildFailed;    set => m_AnyChildFailed    = value; }
    }

    /// <summary>
    /// ECS tag indicating an AdvancedSequence node is currently active.
    /// </summary>
    public struct AdvancedSequenceFlag : IComponentData, IEnableableComponent { }

    /// <summary>
    /// Runs the AdvancedSequence evaluation logic each frame via Burst-compiled ECS job.
    /// </summary>
    [DisableAutoCreation]
    public partial struct AdvancedSequenceTaskSystem : ISystem
    {
        private EntityQuery m_Query;

        private void OnCreate(ref SystemState state)
        {
            m_Query = SystemAPI.QueryBuilder()
                .WithAllRW<BranchComponent>()
                .WithAllRW<TaskComponent>()
                .WithAllRW<AdvancedSequenceComponent>()
                .WithAll<AdvancedSequenceFlag, EvaluateFlag>()
                .Build();
        }

        [BurstCompile]
        private void OnUpdate(ref SystemState state)
        {
            state.Dependency = new AdvancedSequenceJob()
                .ScheduleParallel(m_Query, state.Dependency);
        }

        [BurstCompile]
        private partial struct AdvancedSequenceJob : IJobEntity
        {
            [BurstCompile]
            public void Execute(
                ref DynamicBuffer<BranchComponent> branchComponents,
                ref DynamicBuffer<TaskComponent> taskComponents,
                ref DynamicBuffer<AdvancedSequenceComponent> sequenceComponents)
            {
                for (int i = 0; i < sequenceComponents.Length; ++i)
                {
                    var seqComp = sequenceComponents[i];
                    var taskComp = taskComponents[seqComp.Index];
                    var taskStatus = taskComp.Status;

                    if (taskStatus != TaskStatus.Queued && taskStatus != TaskStatus.Running)
                        continue;

                    var branchComp = branchComponents[taskComp.BranchIndex];
                    if (branchComp.InterruptType != InterruptType.None || !branchComp.CanExecute)
                        continue;

                    // ── First activation: queue the first child ─────────────────────────
                    if (taskStatus == TaskStatus.Queued)
                    {
                        taskComp.Status = TaskStatus.Running;
                        taskComponents[taskComp.Index] = taskComp;

                        seqComp.ActiveChildIndex  = (ushort)(taskComp.Index + 1);
                        seqComp.AnyChildSucceeded = false;
                        seqComp.AnyChildFailed    = false;
                        sequenceComponents[i] = seqComp;

                        branchComp.NextIndex = seqComp.ActiveChildIndex;
                        branchComponents[taskComp.BranchIndex] = branchComp;

                        var firstChild = taskComponents[branchComp.NextIndex];
                        if (firstChild.Status != TaskStatus.Queued)
                        {
                            firstChild.Status = TaskStatus.Queued;
                            taskComponents[branchComp.NextIndex] = firstChild;
                        }
                    }

                    // ── Check the active child's status ─────────────────────────────────
                    var childComp = taskComponents[seqComp.ActiveChildIndex];
                    if (childComp.Status == TaskStatus.Queued || childComp.Status == TaskStatus.Running)
                        continue; // Still running, wait.

                    // Treat Inactive (disabled) children as Success.
                    var childSucceeded = childComp.Status == TaskStatus.Success || childComp.Status == TaskStatus.Inactive;
                    var childFailed    = childComp.Status == TaskStatus.Failure;

                    if (childSucceeded) seqComp.AnyChildSucceeded = true;
                    if (childFailed)    seqComp.AnyChildFailed    = true;

                    // ── Early termination checks ────────────────────────────────────────

                    // OneSuccess: any child succeeding ends the sequence with Success.
                    if (childSucceeded && seqComp.OneSuccessPolicy)
                    {
                        taskComp.Status = TaskStatus.Success;
                        taskComponents[seqComp.Index] = taskComp;

                        branchComp.NextIndex = taskComp.ParentIndex;
                        branchComponents[taskComp.BranchIndex] = branchComp;

                        sequenceComponents[i] = seqComp;
                        continue;
                    }

                    // OneFailure (default): any child failing ends the sequence with Failure.
                    if (childFailed && !seqComp.AllFailurePolicy)
                    {
                        taskComp.Status = TaskStatus.Failure;
                        taskComponents[seqComp.Index] = taskComp;

                        branchComp.NextIndex = taskComp.ParentIndex;
                        branchComponents[taskComp.BranchIndex] = branchComp;

                        sequenceComponents[i] = seqComp;
                        continue;
                    }

                    // ── Advance to next sibling or finalize ─────────────────────────────
                    if (childComp.SiblingIndex == ushort.MaxValue)
                    {
                        // No more children. Determine final result based on policies.
                        bool shouldSucceed = seqComp.OneSuccessPolicy
                            ? seqComp.AnyChildSucceeded
                            : !seqComp.AnyChildFailed;

                        taskComp.Status = shouldSucceed ? TaskStatus.Success : TaskStatus.Failure;
                        seqComp.ActiveChildIndex = (ushort)(seqComp.Index + 1);
                        taskComponents[seqComp.Index] = taskComp;

                        branchComp.NextIndex = taskComp.ParentIndex;
                        branchComponents[taskComp.BranchIndex] = branchComp;
                    }
                    else
                    {
                        // Move to the next sibling.
                        var siblingComp = taskComponents[childComp.SiblingIndex];
                        if (siblingComp.Status != TaskStatus.Queued)
                        {
                            siblingComp.Status = TaskStatus.Queued;
                            taskComponents[childComp.SiblingIndex] = siblingComp;
                        }

                        seqComp.ActiveChildIndex = childComp.SiblingIndex;

                        branchComp.NextIndex = seqComp.ActiveChildIndex;
                        branchComponents[taskComp.BranchIndex] = branchComp;
                    }

                    sequenceComponents[i] = seqComp;
                }
            }
        }
    }

    /// <summary>
    /// Handles interrupt recovery for AdvancedSequence — ensures ActiveChildIndex
    /// points to the correct running child after a conditional abort.
    /// </summary>
    [DisableAutoCreation]
    public partial struct AdvancedSequenceInterruptSystem : ISystem
    {
        [BurstCompile]
        private void OnUpdate(ref SystemState state)
        {
            foreach (var (taskComponents, sequenceComponents) in
                SystemAPI.Query<DynamicBuffer<TaskComponent>, DynamicBuffer<AdvancedSequenceComponent>>()
                    .WithAll<InterruptFlag>())
            {
                for (int i = 0; i < sequenceComponents.Length; ++i)
                {
                    var seqComp = sequenceComponents[i];
                    if (seqComp.ActiveChildIndex == ushort.MaxValue ||
                        seqComp.ActiveChildIndex >= taskComponents.Length)
                        continue;

                    if (taskComponents[seqComp.ActiveChildIndex].Status != TaskStatus.Running)
                    {
                        var childIndex = (ushort)(seqComp.Index + 1);
                        while (childIndex != ushort.MaxValue &&
                               childIndex < taskComponents.Length &&
                               taskComponents[childIndex].Status != TaskStatus.Running)
                        {
                            childIndex = taskComponents[childIndex].SiblingIndex;
                        }

                        if (childIndex != ushort.MaxValue && childIndex < taskComponents.Length)
                        {
                            seqComp.ActiveChildIndex = childIndex;
                        }

                        var buffer = sequenceComponents;
                        buffer[i] = seqComp;
                    }
                }
            }
        }
    }
}
#endif