BehaviorTreeValidator.cpp

Go to the documentation of this file.

#include "Core/BehaviorTreeValidator.h"
#include "Core/Node.h"
#include "Utils/Logger.h"
#include <algorithm>
 
namespace EmberCore {
 
BehaviorTreeValidator::BehaviorTreeValidator() {
    // Use default ParserConfig constructor which provides sensible defaults
}
 
BehaviorTreeValidator::BehaviorTreeValidator(const ParserConfig &config) : config_(config) {}
 
BehaviorTreeValidator::ValidationResult BehaviorTreeValidator::Validate(const BehaviorTree *tree) const {
    ValidationResult result;
 
    if (!tree) {
        result.AddError("Tree is null");
        return result;
    }
 
    // Validate tree structure (including cycle detection)
    ValidateTreeStructure(tree, result);
 
    // Only proceed with node validation if no cycles detected
    // (cycles would cause infinite recursion in ValidateNode)
    bool has_cycles = std::any_of(result.issues.begin(), result.issues.end(),
                                  [](const BehaviorTreeValidator::ValidationIssue &issue) {
                                      return issue.message.find("circular") != EmberCore::String::npos ||
                                             issue.message.find("cycle") != EmberCore::String::npos;
                                  });
 
    if (!has_cycles) {
        // Validate root node and its descendants
        Node *root = tree->GetRootNode();
        if (root) {
            std::vector<const Node *> visited;
            ValidateNode(root, result, visited, "");
        }
    }
 
    // Validate blackboards
    ValidateBlackboards(tree, result);
 
    return result;
}
 
BehaviorTreeValidator::ValidationResult BehaviorTreeValidator::ValidateWithConfig(const BehaviorTree *tree,
                                                                                  const ParserConfig &config) {
    BehaviorTreeValidator validator(config);
    return validator.Validate(tree);
}
 
void BehaviorTreeValidator::ValidateTreeStructure(const BehaviorTree *tree, ValidationResult &result) const {
    // Check for root node
    Node *root = tree->GetRootNode();
    if (!root) {
        result.AddError("Tree has no root node");
        return;
    }
 
    // Check for cycles with protection against infinite recursion
    try {
        std::vector<const Node *> visited;
        visited.reserve(100); // Pre-allocate to reduce reallocation overhead
        if (HasCycles(root, visited)) {
            result.AddError("Tree contains circular references (cycles)");
        }
    } catch (const std::exception &e) {
        result.AddError(EmberCore::String("Cycle detection failed: ") + e.what());
    } catch (...) {
        result.AddError("Cycle detection failed with unknown error (possible circular structure)");
    }
}
 
void BehaviorTreeValidator::ValidateNode(const Node *node, ValidationResult &result, std::vector<const Node *> &visited,
                                         const EmberCore::String &parent_path) const {
    if (!node) {
        result.AddError("Null node found in tree", parent_path);
        return;
    }
 
    // Build path for this node
    EmberCore::String node_path = BuildNodePath(parent_path, node);
 
    // Check for circular reference
    if (std::find(visited.begin(), visited.end(), node) != visited.end()) {
        result.AddError("Circular reference detected", node_path);
        return;
    }
    visited.push_back(node);
 
    // Validate node name
    if (node->GetName().empty()) {
        result.AddError("Node has empty name", node_path);
    }
 
    // Validate node type against profile
    ValidateNodeType(node, result, node_path);
 
    // Validate node attributes against profile
    ValidateNodeAttributes(node, result, node_path);
 
    // Validate child count rules
    ValidateChildCount(node, result, node_path);
 
    // Recursively validate children
    for (size_t i = 0; i < node->GetChildCount(); ++i) {
        const Node *child = node->GetChild(i);
        if (child) {
            ValidateNode(child, result, visited, node_path);
        } else {
            result.AddError("Node has null child at index " + std::to_string(i), node_path);
        }
    }
}
 
void BehaviorTreeValidator::ValidateNodeType(const Node *node, ValidationResult &result,
                                             const EmberCore::String &path) const {
    // Get the node's ID attribute (which contains the specific type like "Sequence", "SetInt")
    const auto &node_config = config_.GetNodeConfig();
    EmberCore::String node_type_id = node->GetAttribute(node_config.node_id_attribute);
 
    // If no ID attribute, this is a problem (needed for serialization)
    if (node_type_id.empty()) {
        result.AddWarning("Node missing '" + node_config.node_id_attribute + "' attribute (required for serialization)",
                          path);
        return;
    }
 
    // Check if the node type is registered in the profile
    bool type_registered = false;
    switch (node->GetType()) {
    case Node::Type::Control:
        type_registered = config_.IsControlType(node_type_id);
        if (!type_registered) {
            result.AddError("Control node type '" + node_type_id + "' not registered in profile", path);
        }
        break;
 
    case Node::Type::Action:
        type_registered = config_.IsActionType(node_type_id);
        // Actions might have empty type lists (accept all)
        if (!type_registered && !config_.GetClassificationConfig().action_types.empty()) {
            result.AddError("Action node type '" + node_type_id + "' not registered in profile", path);
        }
        break;
 
    case Node::Type::Condition:
        type_registered = config_.IsConditionType(node_type_id);
        if (!type_registered && !config_.GetClassificationConfig().condition_types.empty()) {
            result.AddError("Condition node type '" + node_type_id + "' not registered in profile", path);
        }
        break;
 
    case Node::Type::Decorator:
        type_registered = config_.IsDecoratorType(node_type_id);
        if (!type_registered) {
            result.AddError("Decorator node type '" + node_type_id + "' not registered in profile", path);
        }
        break;
 
    default:
        result.AddWarning("Node has unknown type enum value", path);
        break;
    }
}
 
void BehaviorTreeValidator::ValidateNodeAttributes(const Node *node, ValidationResult &result,
                                                   const EmberCore::String &path) const {
    const auto &node_config = config_.GetNodeConfig();
 
    // Check for required ID attribute
    if (!node_config.node_id_attribute.empty()) {
        EmberCore::String id = node->GetAttribute(node_config.node_id_attribute);
        if (id.empty()) {
            result.AddWarning("Node missing required '" + node_config.node_id_attribute + "' attribute", path);
        }
    }
 
    // Check for internal placeholder attributes (should not exist in finalized trees)
    if (node->HasAttribute("__is_placeholder__")) {
        result.AddError("Node has unexpanded SubTree placeholder", path);
    }
 
    // Check for unimplemented SubTree references (warning, not error)
    // These are SubTree nodes that reference trees not found in the parsed files
    if (node->HasAttribute("__unimplemented__")) {
        EmberCore::String subtree_ref = node->GetAttribute("__subtree_ref__", "");
        if (!subtree_ref.empty()) {
            result.AddWarning("SubTree '" + subtree_ref + "' is referenced but not implemented", path);
        } else {
            result.AddWarning("Node references an unimplemented tree", path);
        }
    }
 
    // Check for SubTree references and validate they are resolved
    EmberCore::String subtree_ref = node->GetAttribute("__subtree_ref__", "");
    if (!subtree_ref.empty() && !node->HasAttribute("__unimplemented__")) {
        // SubTree reference exists but not marked as unimplemented - it should have been expanded
        // This is just informational, not an error, as the tree might be deliberately unexpanded
        // for preview purposes
    }
}
 
void BehaviorTreeValidator::ValidateChildCount(const Node *node, ValidationResult &result,
                                               const EmberCore::String &path) const {
    size_t child_count = node->GetChildCount();
 
    switch (node->GetType()) {
    case Node::Type::Decorator:
        if (child_count == 0) {
            result.AddError("Decorator node has no children (must have exactly 1)", path);
        } else if (child_count > 1) {
            result.AddWarning("Decorator node has " + std::to_string(child_count) + " children (should have exactly 1)",
                              path);
        }
        break;
 
    case Node::Type::Control:
        if (child_count == 0) {
            result.AddWarning("Control node has no children", path);
        }
        break;
 
    case Node::Type::Action:
    case Node::Type::Condition:
        if (child_count > 0) {
            result.AddWarning("Leaf node (" + std::to_string(static_cast<int>(node->GetType())) + ") has " +
                                  std::to_string(child_count) + " children (leaf nodes typically have no children)",
                              path);
        }
        break;
 
    default:
        break;
    }
}
 
void BehaviorTreeValidator::ValidateBlackboards(const BehaviorTree *tree, ValidationResult &result) const {
    const auto &blackboards = tree->GetBlackboards();
 
    for (const auto &bb_pair : blackboards) {
        const auto &bb_id = bb_pair.first;
        const auto *blackboard = bb_pair.second.get();
 
        if (!blackboard) {
            result.AddError("Blackboard '" + bb_id + "' is null");
            continue;
        }
 
        // Validate blackboard has an ID
        if (bb_id.empty()) {
            result.AddWarning("Blackboard has empty ID");
        }
 
        // Note: Detailed blackboard entry validation would require access to Blackboard internals
        // For now, just check that the blackboard exists
    }
}
 
EmberCore::String BehaviorTreeValidator::BuildNodePath(const EmberCore::String &parent_path, const Node *node) const {
    EmberCore::String node_name = node->GetName();
    if (node_name.empty()) {
        node_name = "[unnamed]";
    }
 
    if (parent_path.empty()) {
        return node_name;
    }
    return parent_path + "/" + node_name;
}
 
bool BehaviorTreeValidator::HasCycles(const Node *node, std::vector<const Node *> &visited) const {
    if (!node)
        return false;
 
    // Safety check: limit max recursion depth to prevent stack overflow
    constexpr size_t MAX_DEPTH = 500;
    if (visited.size() >= MAX_DEPTH) {
        LOG_ERROR("BehaviorTreeValidator", "Max recursion depth exceeded - likely circular structure");
        return true; // Treat as cycle to prevent stack overflow
    }
 
    // Check if this node is already in the visited stack (cycle detection)
    // Use pointer comparison for exact identity check
    if (std::any_of(visited.begin(), visited.end(),
                    [node](const Node *visited_node) { return visited_node == node; })) {
        return true; // Cycle detected
    }
 
    visited.push_back(node);
 
    // Check all children with nullptr protection
    size_t child_count = 0;
    try {
        child_count = node->GetChildCount();
    } catch (...) {
        LOG_ERROR("BehaviorTreeValidator", "Failed to get child count - possibly corrupted node");
        visited.pop_back();
        return true;
    }
 
    for (size_t i = 0; i < child_count; ++i) {
        const Node *child = nullptr;
        try {
            child = node->GetChild(i);
        } catch (...) {
            LOG_ERROR("BehaviorTreeValidator", "Failed to get child - possibly corrupted tree");
            visited.pop_back();
            return true;
        }
 
        if (child && HasCycles(child, visited)) {
            visited.pop_back();
            return true;
        }
    }
 
    visited.pop_back();
    return false;
}
 
} // namespace EmberCore