#include "FLESHGraph/FLESHCompiler.h"
#include "FLESHGraph/FLESHGraph.h"
#include "FLESHGraph/FLESHGraphNode.h"
#include "Logging/LogMacros.h"

// Define log category
DEFINE_LOG_CATEGORY_STATIC(LogFLESHCompiler, Log, All);

UFLESHCompiler::UFLESHCompiler()
{
    // Initialize default values
    SourceGraph = nullptr;
    bCompilationSuccessful = false;
    ErrorMessage = TEXT("");
}

void UFLESHCompiler::Initialize(UFLESHGraph* InGraph)
{
    // Set source graph
    SourceGraph = InGraph;
    
    // Reset compilation status
    bCompilationSuccessful = false;
    ErrorMessage = TEXT("");
    CompiledNodeData.Empty();
    ExecutionOrder.Empty();
    
    UE_LOG(LogFLESHCompiler, Log, TEXT("FLESH Compiler initialized with graph: %s"), 
        SourceGraph ? *SourceGraph->GetName() : TEXT("Invalid"));
}

bool UFLESHCompiler::Compile()
{
    // Check if source graph is valid
    if (!SourceGraph)
    {
        ErrorMessage = TEXT("Invalid source graph");
        UE_LOG(LogFLESHCompiler, Error, TEXT("FLESH Compiler error: %s"), *ErrorMessage);
        return false;
    }
    
    // Reset compilation data
    CompiledNodeData.Empty();
    ExecutionOrder.Empty();
    
    // Validate graph
    if (!ValidateGraph())
    {
        UE_LOG(LogFLESHCompiler, Error, TEXT("FLESH Compiler error: %s"), *ErrorMessage);
        return false;
    }
    
    // Process all nodes in the graph
    TArray<UFLESHGraphNode*> AllNodes;
    // TODO: Get all nodes from graph
    
    // Process each node
    for (int32 NodeIndex = 0; NodeIndex < AllNodes.Num(); NodeIndex++)
    {
        if (!ProcessNode(AllNodes[NodeIndex], NodeIndex))
        {
            UE_LOG(LogFLESHCompiler, Error, TEXT("FLESH Compiler error: %s"), *ErrorMessage);
            return false;
        }
    }
    
    // Sort nodes in execution order
    SortNodes();
    
    // Set compilation status
    bCompilationSuccessful = true;
    
    UE_LOG(LogFLESHCompiler, Log, TEXT("FLESH Graph compiled successfully. Nodes: %d, Execution order: %d"), 
        CompiledNodeData.Num(), ExecutionOrder.Num());
    
    return true;
}

TArray<FFLESHNodeData> UFLESHCompiler::GetCompiledNodeData() const
{
    return CompiledNodeData;
}

TArray<int32> UFLESHCompiler::GetExecutionOrder() const
{
    return ExecutionOrder;
}

bool UFLESHCompiler::IsCompilationSuccessful() const
{
    return bCompilationSuccessful;
}

FString UFLESHCompiler::GetErrorMessage() const
{
    return ErrorMessage;
}

bool UFLESHCompiler::ProcessNode(UFLESHGraphNode* Node, int32 NodeIndex)
{
    // Check if node is valid
    if (!Node)
    {
        ErrorMessage = FString::Printf(TEXT("Invalid node at index %d"), NodeIndex);
        return false;
    }
    
    // Create node data
    FFLESHNodeData NodeData;
    NodeData.NodeName = FName(*Node->GetNodeTitle());
    // TODO: Set node type and parameters
    
    // Add node data to compiled data
    CompiledNodeData.Add(NodeData);
    
    return true;
}

void UFLESHCompiler::SortNodes()
{
    // TODO: Implement topological sort to determine execution order
    
    // For now, just add all nodes in order
    for (int32 i = 0; i < CompiledNodeData.Num(); i++)
    {
        ExecutionOrder.Add(i);
    }
}

bool UFLESHCompiler::ValidateGraph()
{
    // TODO: Implement graph validation
    
    // Check if source graph is valid
    if (!SourceGraph)
    {
        ErrorMessage = TEXT("Source graph is null");
        return false;
    }
    
    // Check if graph has at least one node
    TArray<UFLESHGraphNode*> AllNodes = SourceGraph->GetAllNodes();
    if (AllNodes.Num() == 0)
    {
        ErrorMessage = TEXT("Graph has no nodes");
        return false;
    }
    
    return true;
}