// .h --------------------

UCLASS()
class UMyProcessor : public UMassProcessor
{
    GENERATED_BODY()
public:
    UMyProcessor();
protected:
    // UMassProcessor overrides
    virtual void ConfigureQueries(const TSharedRef<FMassEntityManager>& EntityManager) override;
    virtual void Execute(FMassEntityManager& EntityManager, FMassExecutionContext& Context) override;
    // ~UMassProcessor overrides

    FMassEntityQuery Query;
};

// .cpp --------------------

UMyProcessor::UMyProcessor()
    : Query(*this) // Initialize the query so it knows which processor owns it.
{
    // Configure defaults like execution phase,
    // if its game thread only,
    // execution order, etc.
}

void UMyProcessor::ConfigureQueries(const TSharedRef<FMassEntityManager>& EntityManager)
{
    Query.AddRequirement<FTransformFragment>(EMassFragmentAccess::ReadOnly);
    
    Query.AddTagRequirement<FMyTag>(EMassFragmentPresence::All);

    // This processor will only run if an entity has a FTransformFragment
    // that can be read, and has FMyTag,
    // Otherwise it is considerd Pruned.
}

void UMyProcessor::Execute(FMassEntityManager& EntityManager, FMassExecutionContext& Context)
{
    // ForEachEntityChunk is what actually binds the per chunk state.
    // The fragment views, the archetype composition check, and the entity iterator
    // are only valid INSIDE this lambda.
    // The lambda's Context is a different instance than the outer one,
    // so do NOT capture the outer Context.
    Query.ForEachEntityChunk(Context, [](FMassExecutionContext& Context)
    {
        // This is how you check if an archetype has a tag.
        const bool HasTag = Context.DoesArchetypeHaveTag<FMyTag>();

        // Get the transform's to iterate over.
        // GetFragmentView returns a TConstArrayView, which matches the ReadOnly requirement
        // we declared. If you need to write, declare EMassFragmentAccess::ReadWrite and use
        // GetMutableFragmentView, which returns a TArrayView instead.
        const TConstArrayView<FTransformFragment> TransformView = Context.GetFragmentView<FTransformFragment>();

        for (FMassExecutionContext::FEntityIterator Itr = Context.CreateEntityIterator(); Itr; ++Itr)
        {
            // We technically already checked it with the archetype check and this shouldn't fail because of our Query.
            // This is just to show how to check for a tag on a single entity.
            if (!FMassEntityView(Context.GetEntityManagerChecked(), Context.GetEntity(Itr)).HasTag<FMyTag>())
            {
                continue;
            }

            const FTransformFragment& TransformFragment = TransformView[Itr];

            // Do stuff with transform fragment...

            // If you wanted to destroy this entity,
            // you have to defer the operation since
            // we're iterating the list of entities right now.
            Context.Defer().DestroyEntity(Context.GetEntity(Itr));
        }

        // OR you can use the function version for iterating over each entity.
        // Note: the lambda IS the per entity body, the loop lives inside
        // ForEachEntityInChunk. So use `return` to skip an entity, not `continue`.
        Context.ForEachEntityInChunk([&TransformView](FMassExecutionContext& Context, int32 EntityIndex)
        {
            // We technically already checked it with the archetype check and this shouldn't fail because of our Query.
            // This is just to show how to check for a tag on a single entity.
            if (!FMassEntityView(Context.GetEntityManagerChecked(), Context.GetEntity(EntityIndex)).HasTag<FMyTag>())
            {
                return;
            }

            const FTransformFragment& TransformFragment = TransformView[EntityIndex];

            // Do stuff with transform fragment...

            // If you wanted to destroy this entity,
            // you have to defer the operation since
            // we're iterating the list of entities right now.
            Context.Defer().DestroyEntity(Context.GetEntity(EntityIndex));
        });
    });
}

// MassProcessor.h

struct FDependencyNode
{
    FName Name;
    UMassProcessor* Processor;
    TArray<int32> Dependencies;
};

// ---------------------------------------------------

// Handles sorting and building the graph.
virtual void BuildFlatProcessingGraph(TConstArrayView<FMassProcessorOrderInfo> SortedProcessors);

// Allow for nesting "A.B.C"
void AddGroupedProcessor(FName RequestedGroupName, UMassProcessor& SubProcessor);

enum class EActivationState : uint8
{
    Inactive,
    Active,
    /** Auto-disables after the next ::CallExecute() */
    OneShot
};

// .h

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    void RunSpecialProcessors(FMassEntityManager& EntityManager, 
        const TArray<TSubclassOf<UMassProcessor>>& ProcessorTypes,
        const TArray<FMassArchetypeEntityCollection>& EntityCollections,
        FMyPayloadData PayloadData);

    // A common practice is to cache any Processors you create.
    UPROPERTY(Transient)
    TArray<TObjectPtr<UMassProcessor>> CachedProcessors;
};

// ~.h
//////////////////////////////////////////////
// .cpp

void AMyActor::RunSpecialProcessors(TSharedPtr<FMassEntityManager> EntityManager, 
    const TArray<TSubclassOf<UMassProcessor>>& ProcessorTypes,
    const TArray<FMassArchetypeEntityCollection>& EntityCollections,
    const FMyPayloadData& PayloadData)
{ 
    if (!EntityManager.IsValid())
    {
        UE_LOG(LogTemp, Error, TEXT("Inputted NULL EntityManager to AMyActor(%s)"), *GetName());
        return;
    }

    // First lets collect the Processors to run based on our inputted types
    TArray<UMassProcessor*> Processors;
    for (const TSubclassOf<UMassProcessor>& Type : ProcessorTypes)
    {
        if (!Type)
        {
            continue;
        }

        // Check if we already made a Processor, and can just reuse it
        TObjectPtr<UMassProcessor>* const FoundProcessor = CachedProcessors.FindByPredicate[&Type](const UMassProcessor* Processor)
        {
            return Processor && Processor->GetClass() == Type;
        });
        
        // If we failed to find it then lets make one and cache it for later
        if (!FoundProcessor)
        {
            UMassProcessor* NewProcessor = NewObject<UMassProcessor>(this, Type);

            // Handles internally initializing it and setting it up properly for Mass usage
            NewProcessor->CallInitialize(this, EntityManager.ToSharedRef());

            CachedProcessors.Add(NewProcessor);
        } 

        Processors.Add(NewProcessor);
    }

    // Setting up our context data to pass into the Processors
    FMassProcessingContext ProcessingContext(EntityManager, 
        /*DeltaTime*/ 0.0f, 
        /*bInFlushCommandBuffer*/ false);
    
    // AuxData is probably renamed to PayloadData by the time your reading this.
    // Providing optional data for these Processors.
    ProcessingContext.AuxData = FConstStructView::Make(PayloadData);

    // Run our Processors on the inputted Entities(EntityCollections) so it has that context.
    UE::Mass::Executor::RunProcessorsView(MakeArrayView(Processors), ProcessingContext, EntityCollections);
}

// ~.cpp