BehaviorTreeProject.cpp

Go to the documentation of this file.

#include "Parsers/BehaviorTreeProject.h"
#include "Parsers/LibXMLBehaviorTreeParser.h"
#include "Utils/Logger.h"
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <numeric>
#include <sstream>
 
// Platform-specific path handling
#ifdef _WIN32
#include <direct.h>
#define PATH_SEPARATOR '\\'
#else
#include <unistd.h>
#define PATH_SEPARATOR '/'
#endif
 
namespace EmberCore {
 
// ============================================================================
// ProjectValidationReport Implementation
// ============================================================================
 
int ProjectValidationReport::GetValidFileCount() const {
    return std::count_if(resource_statuses.begin(), resource_statuses.end(),
                         [](const ResourceValidationStatus &status) { return status.IsValid(); });
}
 
int ProjectValidationReport::GetTotalTreeCount() const {
    return std::accumulate(resource_statuses.begin(), resource_statuses.end(), 0,
                           [](int sum, const ResourceValidationStatus &status) { return sum + status.tree_count; });
}
 
int ProjectValidationReport::GetImplementedTreeCount() const {
    return std::count_if(tree_statuses.begin(), tree_statuses.end(),
                         [](const auto &pair) { return pair.second.is_implemented; });
}
 
String ProjectValidationReport::GenerateReport() const {
    std::ostringstream report;
 
    report << "=== BehaviorTree Project Validation Report ===\n\n";
    report << "Files: " << resource_statuses.size() << " XML files\n\n";
 
    // Valid files
    int valid_count = GetValidFileCount();
    report << "VALID FILES (" << valid_count << "):\n";
    for (const auto &status : resource_statuses) {
        if (status.IsValid()) {
            report << "  [OK] " << status.filepath << " (" << status.tree_count << " trees)\n";
        }
    }
    report << "\n";
 
    // Invalid files
    int invalid_count = static_cast<int>(resource_statuses.size()) - valid_count;
    if (invalid_count > 0) {
        report << "INVALID FILES (" << invalid_count << "):\n";
        for (const auto &status : resource_statuses) {
            if (!status.IsValid()) {
                report << "  [ERROR] " << status.filepath << "\n";
                for (const auto &err : status.errors) {
                    report << "    - " << err << "\n";
                }
            }
        }
        report << "\n";
    }
 
    // Warnings
    if (!warnings.empty() || !unimplemented_trees.empty()) {
        report << "WARNINGS (" << (warnings.size() + unimplemented_trees.size()) << "):\n";
        for (const auto &warn : warnings) {
            report << "  [WARN] " << warn << "\n";
        }
        for (const auto &tree : unimplemented_trees) {
            report << "  [WARN] Tree '" << tree << "' is referenced but not implemented\n";
        }
        report << "\n";
    }
 
    // Errors
    if (!errors.empty() || !circular_references.empty()) {
        report << "ERRORS (" << (errors.size() + circular_references.size()) << "):\n";
        for (const auto &err : errors) {
            report << "  [ERROR] " << err << "\n";
        }
        for (const auto &ref : circular_references) {
            report << "  [ERROR] Circular reference detected: " << ref << "\n";
        }
        report << "\n";
    }
 
    // Tree reference map
    report << "TREE REFERENCE MAP:\n";
    for (const auto &pair : tree_statuses) {
        const auto &id = pair.first;
        const auto &status = pair.second;
        if (status.is_implemented) {
            report << "  [OK] " << id << " (implemented in " << status.defined_in_file << ")\n";
        } else {
            report << "  [!!] " << id << " (not implemented)\n";
        }
        for (const auto &ref_file : status.referenced_in_files) {
            report << "    <- referenced by " << ref_file << "\n";
        }
    }
 
    return report.str();
}
 
// ============================================================================
// BehaviorTreeProject Implementation
// ============================================================================
 
BehaviorTreeProject::BehaviorTreeProject()
    : name_("Unnamed Project"), description_(""), version_("1.0"), created_timestamp_(GetCurrentTimestamp()),
      modified_timestamp_(GetCurrentTimestamp()), parser_profile_name_("Default") {}
 
BehaviorTreeProject::BehaviorTreeProject(const String &name, const String &description)
    : name_(name), description_(description), version_("1.0"), created_timestamp_(GetCurrentTimestamp()),
      modified_timestamp_(GetCurrentTimestamp()), parser_profile_name_("Default") {}
 
void BehaviorTreeProject::SetName(const String &name) {
    name_ = name;
    UpdateModifiedTimestamp();
}
 
void BehaviorTreeProject::SetDescription(const String &description) {
    description_ = description;
    UpdateModifiedTimestamp();
}
 
void BehaviorTreeProject::UpdateModifiedTimestamp() { modified_timestamp_ = GetCurrentTimestamp(); }
 
void BehaviorTreeProject::SetParserProfileName(const String &profile_name) {
    parser_profile_name_ = profile_name;
    UpdateModifiedTimestamp();
}
 
bool BehaviorTreeProject::AddResource(const String &filepath) {
    // Check if already exists
    if (HasResource(filepath)) {
        LOG_WARNING("BehaviorTreeProject", "Resource already exists in project: " + filepath);
        return false;
    }
 
    resources_.push_back(filepath);
    UpdateModifiedTimestamp();
    LOG_INFO("BehaviorTreeProject", "Added resource: " + filepath);
    return true;
}
 
bool BehaviorTreeProject::RemoveResource(const String &filepath) {
    auto it = std::find(resources_.begin(), resources_.end(), filepath);
    if (it != resources_.end()) {
        resources_.erase(it);
        UpdateModifiedTimestamp();
        LOG_INFO("BehaviorTreeProject", "Removed resource: " + filepath);
        return true;
    }
 
    LOG_WARNING("BehaviorTreeProject", "Resource not found in project: " + filepath);
    return false;
}
 
bool BehaviorTreeProject::HasResource(const String &filepath) const {
    return std::find(resources_.begin(), resources_.end(), filepath) != resources_.end();
}
 
void BehaviorTreeProject::ClearResources() {
    resources_.clear();
    tree_statuses_.clear();
    UpdateModifiedTimestamp();
}
 
String BehaviorTreeProject::GetBaseDirectory() const {
    if (project_filepath_.empty()) {
        // If no project file, use current directory
        char cwd[1024];
#ifdef _WIN32
        _getcwd(cwd, sizeof(cwd));
#else
        getcwd(cwd, sizeof(cwd));
#endif
        return String(cwd);
    }
 
    // Extract directory from project file path
    size_t last_sep = project_filepath_.find_last_of("/\\");
    if (last_sep != String::npos) {
        return project_filepath_.substr(0, last_sep);
    }
    return ".";
}
 
String BehaviorTreeProject::ResolveResourcePath(const String &resource_path) const {
    // If already absolute, return as-is
    if (!resource_path.empty() &&
        (resource_path[0] == '/' || (resource_path.length() > 1 && resource_path[1] == ':'))) {
        return resource_path;
    }
 
    // Resolve relative to project base directory
    String base = GetBaseDirectory();
    if (base.empty() || base == ".") {
        return resource_path;
    }
 
    return base + PATH_SEPARATOR + resource_path;
}
 
String BehaviorTreeProject::MakeRelativePath(const String &absolute_path) const {
    String base = GetBaseDirectory();
    if (base.empty()) {
        return absolute_path;
    }
 
    // Normalize separators
    String normalized_path = absolute_path;
    String normalized_base = base;
    std::replace(normalized_path.begin(), normalized_path.end(), '\\', '/');
    std::replace(normalized_base.begin(), normalized_base.end(), '\\', '/');
 
    // Check if path starts with base
    if (normalized_path.find(normalized_base) == 0) {
        String relative = normalized_path.substr(normalized_base.length());
        if (!relative.empty() && relative[0] == '/') {
            relative = relative.substr(1);
        }
        return relative;
    }
 
    // Can't make relative, return absolute
    return absolute_path;
}
 
// Helper function to recursively extract SubTree references
static void ExtractSubTreeReferences(xmlNodePtr node, std::set<String> &subtree_refs) {
    if (!node)
        return;
 
    for (xmlNodePtr child = node->children; child; child = child->next) {
        if (child->type == XML_ELEMENT_NODE) {
            const char *name = reinterpret_cast<const char *>(child->name);
 
            // Check if this is a SubTree element
            if (name && strcmp(name, "SubTree") == 0) {
                xmlChar *id_attr = xmlGetProp(child, reinterpret_cast<const xmlChar *>("ID"));
                if (id_attr) {
                    subtree_refs.insert(reinterpret_cast<const char *>(id_attr));
                    xmlFree(id_attr);
                }
            }
 
            // Recursively search children
            ExtractSubTreeReferences(child, subtree_refs);
        }
    }
}
 
ResourceValidationStatus BehaviorTreeProject::ValidateSingleResource(const String &filepath) const {
    ResourceValidationStatus status;
    status.filepath = filepath;
 
    String resolved_path = ResolveResourcePath(filepath);
 
    // Check if file exists
    std::ifstream file(resolved_path);
    if (!file.good()) {
        status.errors.push_back("File not found: " + resolved_path);
        return status;
    }
    status.exists = true;
    file.close();
 
    // Try to parse as XML
    xmlDocPtr doc = xmlReadFile(resolved_path.c_str(), nullptr, XML_PARSE_NOERROR | XML_PARSE_NOWARNING);
    if (!doc) {
        status.errors.push_back("Invalid XML syntax");
        return status;
    }
    status.is_valid_xml = true;
 
    // Check for BehaviorTree elements
    xmlNodePtr root = xmlDocGetRootElement(doc);
    if (!root) {
        xmlFreeDoc(doc);
        status.errors.push_back("XML document has no root element");
        return status;
    }
 
    // Track SubTree references across all trees in this file
    std::set<String> subtree_refs;
 
    // Look for BehaviorTree and Blackboard elements
    std::set<String> blackboard_includes;
 
    for (xmlNodePtr child = root->children; child; child = child->next) {
        if (child->type == XML_ELEMENT_NODE) {
            const char *name = reinterpret_cast<const char *>(child->name);
            if (name && strcmp(name, "BehaviorTree") == 0) {
                status.has_behavior_trees = true;
                status.tree_count++;
 
                // Get tree ID
                xmlChar *id_attr = xmlGetProp(child, reinterpret_cast<const xmlChar *>("ID"));
                if (id_attr) {
                    status.tree_ids.push_back(reinterpret_cast<const char *>(id_attr));
                    xmlFree(id_attr);
                }
 
                // Extract SubTree references from this tree
                ExtractSubTreeReferences(child, subtree_refs);
            } else if (name && strcmp(name, "Blackboard") == 0) {
                status.has_blackboards = true;
                status.blackboard_count++;
 
                // Get blackboard ID
                String bbId;
                xmlChar *id_attr = xmlGetProp(child, reinterpret_cast<const xmlChar *>("ID"));
                if (id_attr) {
                    bbId = reinterpret_cast<const char *>(id_attr);
                    status.blackboard_ids.push_back(bbId);
                    xmlFree(id_attr);
                } else {
                    status.errors.push_back("Blackboard element missing required 'ID' attribute");
                }
 
                // Get includes attribute and parse {ID1 ID2 ...} format
                xmlChar *includes_attr = xmlGetProp(child, reinterpret_cast<const xmlChar *>("includes"));
                if (includes_attr) {
                    String includes_str = reinterpret_cast<const char *>(includes_attr);
                    xmlFree(includes_attr);
 
                    // Validate includes syntax - must be in {ID1 ID2 ...} format
                    if (!includes_str.empty()) {
                        if (includes_str.front() != '{' || includes_str.back() != '}') {
                            status.warnings.push_back("Blackboard '" + bbId +
                                                      "' has malformed includes syntax (should be {ID1 ID2 ...})");
                        } else {
                            // Parse {ID1 ID2 ID3} format - strip braces and split by spaces
                            includes_str = includes_str.substr(1, includes_str.size() - 2);
                            // Split by whitespace
                            std::istringstream iss(includes_str);
                            String token;
                            while (iss >> token) {
                                if (!token.empty()) {
                                    blackboard_includes.insert(token);
                                }
                            }
                        }
                    }
                }
 
                // Validate blackboard entries
                std::set<String> seenKeys;
                for (xmlNodePtr entryNode = child->children; entryNode; entryNode = entryNode->next) {
                    if (entryNode->type != XML_ELEMENT_NODE)
                        continue;
                    const char *entryName = reinterpret_cast<const char *>(entryNode->name);
                    if (!entryName || strcmp(entryName, "Entry") != 0)
                        continue;
 
                    // Check for required 'key' attribute
                    xmlChar *keyAttr = xmlGetProp(entryNode, reinterpret_cast<const xmlChar *>("key"));
                    if (!keyAttr) {
                        status.errors.push_back("Blackboard '" + bbId + "' has Entry missing required 'key' attribute");
                        continue;
                    }
                    String entryKey = reinterpret_cast<const char *>(keyAttr);
                    xmlFree(keyAttr);
 
                    // Check for duplicate keys within this blackboard
                    if (seenKeys.count(entryKey) > 0) {
                        status.warnings.push_back("Blackboard '" + bbId + "' has duplicate entry key: " + entryKey);
                    }
                    seenKeys.insert(entryKey);
 
                    // Check for required 'type' attribute
                    xmlChar *typeAttr = xmlGetProp(entryNode, reinterpret_cast<const xmlChar *>("type"));
                    if (!typeAttr) {
                        status.errors.push_back("Blackboard '" + bbId + "' entry '" + entryKey +
                                                "' missing required 'type' attribute");
                        continue;
                    }
                    String entryType = reinterpret_cast<const char *>(typeAttr);
                    xmlFree(typeAttr);
 
                    // Validate type against known types
                    static const std::set<String> validTypes = {
                        "bool", "int", "int8", "float", "string", "Currency", "uint8_t", "uint32_t", "size_t", "auto",
                        "vec(int)", "vec(int8)", "vec(uint8_t)", "vec(uint32_t)", "vec(float)", "vec(string)",
                        "vec(Currency)", "vec(vec(uint8_t))", "vec(vec(uint32_t))", "vec(pair(float))", "pair(float)",
                        "pair(int)", "pair(string)", "map(string, string)", "map(string,string)", "map(string, int)",
                        "map(string,int)", "set(string)", "set(int)", "set(uint32_t)", "set",
                        // Custom types (we allow these as they may be game-specific)
                        "Results", "ReelFigs", "GameSounds"};
 
                    // Check if it's a valid type or a custom type (starts with uppercase, no parens)
                    bool isValidType = validTypes.count(entryType) > 0;
                    bool isCustomType = !entryType.empty() && std::isupper(entryType[0]) &&
                                        entryType.find('(') == String::npos && entryType.find(')') == String::npos;
 
                    if (!isValidType && !isCustomType) {
                        status.warnings.push_back("Blackboard '" + bbId + "' entry '" + entryKey +
                                                  "' has unsupported type: " + entryType);
                    }
                }
            }
        }
    }
 
    // Convert sets to vectors
    status.subtree_refs.assign(subtree_refs.begin(), subtree_refs.end());
    status.blackboard_includes.assign(blackboard_includes.begin(), blackboard_includes.end());
 
    xmlFreeDoc(doc);
 
    if (!status.has_behavior_trees && !status.has_blackboards) {
        status.warnings.push_back("No BehaviorTree or Blackboard elements found in file");
    }
 
    return status;
}
 
ProjectValidationReport BehaviorTreeProject::ValidateResources() const {
    ProjectValidationReport report;
 
    if (resources_.empty()) {
        report.errors.push_back("Project has no resources");
        return report;
    }
 
    // Validate each resource
    std::set<String> all_tree_ids;
    std::set<String> duplicate_tree_ids;
    std::set<String> all_subtree_refs;
    std::map<String, std::vector<String>> subtree_to_files; // Track which files reference which subtrees
 
    for (const auto &resource : resources_) {
        ResourceValidationStatus status = ValidateSingleResource(resource);
 
        // Check for duplicates within this file
        std::set<String> seen_in_file;
        for (const auto &tree_id : status.tree_ids) {
            if (seen_in_file.count(tree_id) > 0) {
                // Found duplicate within same file
                status.warnings.push_back("Duplicate tree ID within file: " + tree_id);
            }
            seen_in_file.insert(tree_id);
        }
 
        report.resource_statuses.push_back(status);
 
        // Track tree IDs for duplicate detection
        for (const auto &tree_id : status.tree_ids) {
            if (all_tree_ids.count(tree_id) > 0) {
                duplicate_tree_ids.insert(tree_id);
                // Also add a warning to the specific file
                const_cast<ResourceValidationStatus &>(status).warnings.push_back("Duplicate tree ID in project: " +
                                                                                  tree_id);
            }
            all_tree_ids.insert(tree_id);
 
            // Create initial tree status
            if (report.tree_statuses.find(tree_id) == report.tree_statuses.end()) {
                TreeImplementationStatus tree_status(tree_id);
                tree_status.is_implemented = true;
                tree_status.has_root_node = true; // Assume valid for now
                tree_status.defined_in_file = resource;
                report.tree_statuses[tree_id] = tree_status;
            }
        }
 
        // Track SubTree references
        for (const auto &subtree_id : status.subtree_refs) {
            all_subtree_refs.insert(subtree_id);
            subtree_to_files[subtree_id].push_back(resource);
        }
    }
 
    // Check for unimplemented SubTree references
    for (const auto &subtree_id : all_subtree_refs) {
        if (all_tree_ids.find(subtree_id) == all_tree_ids.end()) {
            // This SubTree is referenced but not implemented in any file
            report.unimplemented_trees.push_back(subtree_id);
 
            // Create tree status for unimplemented tree
            TreeImplementationStatus tree_status(subtree_id);
            tree_status.is_implemented = false;
            tree_status.has_root_node = false;
            tree_status.referenced_in_files = subtree_to_files[subtree_id];
            report.tree_statuses[subtree_id] = tree_status;
        } else {
            // Update the implemented tree's referenced_in_files
            report.tree_statuses[subtree_id].referenced_in_files = subtree_to_files[subtree_id];
        }
    }
 
    // Report duplicate tree IDs
    for (const auto &dup : duplicate_tree_ids) {
        report.warnings.push_back("Duplicate tree ID found: " + dup);
    }
 
    // ---- Blackboard cross-file validation ----
    std::set<String> all_blackboard_ids;
    std::set<String> duplicate_bb_ids;
    std::set<String> all_bb_includes;
 
    for (auto &res_status : report.resource_statuses) {
        // Check for duplicate blackboard IDs within this file
        std::set<String> seen_bb_in_file;
        for (const auto &bb_id : res_status.blackboard_ids) {
            if (seen_bb_in_file.count(bb_id) > 0) {
                res_status.warnings.push_back("Duplicate blackboard ID within file: " + bb_id);
            }
            seen_bb_in_file.insert(bb_id);
        }
 
        // Check for duplicate blackboard IDs across files
        for (const auto &bb_id : res_status.blackboard_ids) {
            if (all_blackboard_ids.count(bb_id) > 0) {
                duplicate_bb_ids.insert(bb_id);
                res_status.warnings.push_back("Duplicate blackboard ID in project: " + bb_id);
            }
            all_blackboard_ids.insert(bb_id);
        }
 
        // Collect all includes for later resolution check
        for (const auto &inc : res_status.blackboard_includes) {
            all_bb_includes.insert(inc);
        }
    }
 
    // Report duplicate blackboard IDs at project level
    for (const auto &dup : duplicate_bb_ids) {
        report.duplicate_blackboard_ids.push_back(dup);
        report.warnings.push_back("Duplicate blackboard ID found: " + dup);
    }
 
    // Check for unresolved blackboard includes
    for (const auto &inc : all_bb_includes) {
        if (all_blackboard_ids.find(inc) == all_blackboard_ids.end()) {
            report.unresolved_blackboard_includes.push_back(inc);
            report.warnings.push_back("Unresolved blackboard include: " + inc);
 
            // Also add a file-level warning to the files that reference this include
            for (auto &res_status : report.resource_statuses) {
                if (std::any_of(res_status.blackboard_includes.begin(), res_status.blackboard_includes.end(),
                                [&inc](const String &file_inc) { return file_inc == inc; })) {
                    res_status.warnings.push_back("Missing blackboard include: " + inc);
                }
            }
        }
    }
 
    // Check if any file has errors
    report.is_valid = !std::any_of(report.resource_statuses.begin(), report.resource_statuses.end(),
                                   [](const ResourceValidationStatus &status) { return !status.errors.empty(); });
 
    // Add unimplemented trees from our stored status
    for (const auto &pair : tree_statuses_) {
        const auto &id = pair.first;
        const auto &status = pair.second;
        if (!status.is_implemented) {
            report.unimplemented_trees.push_back(id);
 
            // Update or add to tree statuses
            report.tree_statuses[id] = status;
        }
    }
 
    return report;
}
 
bool BehaviorTreeProject::IsValid() const {
    ProjectValidationReport report = ValidateResources();
    return report.is_valid;
}
 
ProjectValidationReport BehaviorTreeProject::ValidateWithParser(LibXMLBehaviorTreeParser *parser) const {
    ProjectValidationReport report;
 
    if (!parser) {
        report.is_valid = false;
        report.errors.push_back("Parser is null");
        return report;
    }
 
    if (resources_.empty()) {
        report.is_valid = false;
        report.errors.push_back("No resources in project");
        return report;
    }
 
    // Use parser to validate the project
    auto parse_result = parser->ParseProject(const_cast<BehaviorTreeProject *>(this));
 
    // Convert FileParseInfo to ResourceValidationStatus
    for (const auto &fileInfo : parse_result.file_infos) {
        ResourceValidationStatus status;
        status.filepath = fileInfo.filepath;
        status.exists = true; // If parsing reached here, file exists
        status.is_valid_xml = fileInfo.parsed_successfully;
        status.has_behavior_trees = fileInfo.has_behavior_trees;
        status.has_blackboards = fileInfo.has_blackboards;
        status.tree_count = fileInfo.tree_count;
        status.blackboard_count = fileInfo.blackboard_count;
        status.tree_ids = fileInfo.tree_ids;
        status.blackboard_ids = fileInfo.blackboard_ids;
        status.subtree_refs = fileInfo.subtree_refs;
        status.blackboard_includes = fileInfo.blackboard_includes;
        status.errors = fileInfo.errors;
        status.warnings = fileInfo.warnings;
 
        report.resource_statuses.push_back(status);
 
        // Propagate file-level errors to top-level report
        for (const auto &error : fileInfo.errors) {
            report.errors.push_back(error);
        }
 
        // Propagate file-level warnings to top-level report
        for (const auto &warning : fileInfo.warnings) {
            report.warnings.push_back(warning);
        }
    }
 
    // Convert ParseError to strings
    for (const auto &err : parse_result.errors) {
        report.errors.push_back(err.message + " (" + err.file_path + ")");
    }
 
    // Append project-level warnings (don't overwrite file-level warnings)
    for (const auto &warning : parse_result.warnings) {
        report.warnings.push_back(warning);
    }
 
    // Copy tree statuses
    report.tree_statuses = parse_result.tree_statuses;
 
    // Copy unimplemented references
    report.unimplemented_trees = parse_result.unimplemented_references;
 
    // Copy blackboard issues
    report.unresolved_blackboard_includes = parse_result.unresolved_blackboard_includes;
    report.duplicate_blackboard_ids = parse_result.duplicate_blackboard_ids;
 
    // Copy circular references
    report.circular_references = parse_result.circular_references;
 
    // Add duplicate tree IDs to warnings and errors
    for (const auto &dup_id : parse_result.duplicate_tree_ids) {
        // Find which files have this duplicate and add to their status
        for (auto &status : report.resource_statuses) {
            if (std::find(status.tree_ids.begin(), status.tree_ids.end(), dup_id) != status.tree_ids.end()) {
                status.warnings.push_back("Duplicate tree ID found: " + dup_id);
            }
        }
    }
 
    // Add duplicate blackboard IDs to warnings
    for (const auto &dup_id : parse_result.duplicate_blackboard_ids) {
        for (auto &status : report.resource_statuses) {
            if (std::find(status.blackboard_ids.begin(), status.blackboard_ids.end(), dup_id) !=
                status.blackboard_ids.end()) {
                status.warnings.push_back("Duplicate blackboard ID found: " + dup_id);
            }
        }
    }
 
    // Add unresolved blackboard includes to warnings
    for (const auto &unresolved : parse_result.unresolved_blackboard_includes) {
        for (auto &status : report.resource_statuses) {
            if (std::find(status.blackboard_includes.begin(), status.blackboard_includes.end(), unresolved) !=
                status.blackboard_includes.end()) {
                status.warnings.push_back("Unresolved blackboard include: " + unresolved);
            }
        }
    }
 
    // Determine overall validity
    report.is_valid = parse_result.success && report.errors.empty();
 
    // Even with warnings, the project can be valid
    if (std::any_of(report.resource_statuses.begin(), report.resource_statuses.end(),
                    [](const ResourceValidationStatus &status) { return !status.IsValid(); })) {
        report.is_valid = false;
    }
 
    return report;
}
 
void BehaviorTreeProject::SetTreeImplementationStatus(const std::map<String, TreeImplementationStatus> &statuses) {
    tree_statuses_ = statuses;
}
 
std::vector<String> BehaviorTreeProject::GetUnimplementedReferences() const {
    std::vector<String> unimplemented;
    for (const auto &pair : tree_statuses_) {
        const auto &status = pair.second;
        if (!status.is_implemented && !status.referenced_in_files.empty()) {
            unimplemented.push_back(pair.first);
        }
    }
    return unimplemented;
}
 
std::vector<String> BehaviorTreeProject::GetImplementedTrees() const {
    std::vector<String> implemented;
    for (const auto &pair : tree_statuses_) {
        if (pair.second.is_implemented) {
            implemented.push_back(pair.first);
        }
    }
    return implemented;
}
 
bool BehaviorTreeProject::IsTreeImplemented(const String &tree_id) const {
    auto it = tree_statuses_.find(tree_id);
    if (it != tree_statuses_.end()) {
        return it->second.is_implemented;
    }
    return false;
}
 
nlohmann::json BehaviorTreeProject::ToJson() const {
    nlohmann::json json;
 
    json["project_name"] = name_;
    json["description"] = description_;
    json["version"] = version_;
    json["created_timestamp"] = created_timestamp_;
    json["modified_timestamp"] = modified_timestamp_;
    json["parser_profile"] = parser_profile_name_;
    json["resources"] = resources_;
 
    // Serialize tree implementation statuses
    nlohmann::json tree_statuses_json = nlohmann::json::array();
    for (const auto &pair : tree_statuses_) {
        const auto &status = pair.second;
        nlohmann::json status_json;
        status_json["tree_id"] = status.tree_id;
        status_json["is_implemented"] = status.is_implemented;
        status_json["has_root_node"] = status.has_root_node;
        status_json["defined_in_file"] = status.defined_in_file;
        status_json["referenced_in_files"] = status.referenced_in_files;
        tree_statuses_json.push_back(status_json);
    }
    json["tree_statuses"] = tree_statuses_json;
 
    return json;
}
 
void BehaviorTreeProject::FromJson(const nlohmann::json &json) {
    try {
        // Validate required fields
        if (!json.contains("project_name")) {
            throw std::runtime_error("Missing required field: project_name");
        }
 
        // Load required fields
        name_ = json["project_name"].get<String>();
 
        // Load optional fields
        if (json.contains("description")) {
            description_ = json["description"].get<String>();
        }
        if (json.contains("version")) {
            version_ = json["version"].get<String>();
        }
        if (json.contains("created_timestamp")) {
            created_timestamp_ = json["created_timestamp"].get<int64_t>();
        }
        if (json.contains("modified_timestamp")) {
            modified_timestamp_ = json["modified_timestamp"].get<int64_t>();
        }
        if (json.contains("parser_profile")) {
            parser_profile_name_ = json["parser_profile"].get<String>();
        }
        if (json.contains("resources")) {
            resources_ = json["resources"].get<std::vector<String>>();
        }
 
        // Load tree statuses
        tree_statuses_.clear();
        if (json.contains("tree_statuses")) {
            for (const auto &status_json : json["tree_statuses"]) {
                TreeImplementationStatus status;
                status.tree_id = status_json["tree_id"].get<String>();
                status.is_implemented = status_json.value("is_implemented", false);
                status.has_root_node = status_json.value("has_root_node", false);
                status.defined_in_file = status_json.value("defined_in_file", "");
                if (status_json.contains("referenced_in_files")) {
                    status.referenced_in_files = status_json["referenced_in_files"].get<std::vector<String>>();
                }
                tree_statuses_[status.tree_id] = status;
            }
        }
 
    } catch (const std::exception &e) {
        LOG_ERROR("BehaviorTreeProject", "Error parsing JSON project: " + std::string(e.what()));
        throw;
    }
}
 
bool BehaviorTreeProject::SaveToFile(const String &filepath) {
    try {
        project_filepath_ = filepath;
 
        nlohmann::json json = ToJson();
        std::ofstream file(filepath);
 
        if (!file.is_open()) {
            LOG_ERROR("BehaviorTreeProject", "Failed to open file for writing: " + filepath);
            return false;
        }
 
        // Write with pretty formatting (4 space indent)
        file << std::setw(4) << json << std::endl;
        file.close();
 
        LOG_INFO("BehaviorTreeProject", "Saved project '" + name_ + "' to: " + filepath);
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("BehaviorTreeProject", "Error saving project to file: " + std::string(e.what()));
        return false;
    }
}
 
bool BehaviorTreeProject::LoadFromFile(const String &filepath) {
    try {
        std::ifstream file(filepath);
 
        if (!file.is_open()) {
            LOG_ERROR("BehaviorTreeProject", "Failed to open file for reading: " + filepath);
            return false;
        }
 
        nlohmann::json json;
        file >> json;
        file.close();
 
        FromJson(json);
        project_filepath_ = filepath;
 
        LOG_INFO("BehaviorTreeProject", "Loaded project '" + name_ + "' from: " + filepath);
        return true;
    } catch (const std::exception &e) {
        LOG_ERROR("BehaviorTreeProject", "Error loading project from file: " + std::string(e.what()));
        return false;
    }
}
 
std::shared_ptr<BehaviorTreeProject> BehaviorTreeProject::Clone(const String &new_name) const {
    String cloned_name = new_name.empty() ? name_ + " (Copy)" : new_name;
    auto cloned = std::make_shared<BehaviorTreeProject>(cloned_name, description_);
 
    cloned->SetVersion(version_);
    cloned->SetParserProfileName(parser_profile_name_);
 
    // Copy resources
    for (const auto &resource : resources_) {
        cloned->AddResource(resource);
    }
 
    // Copy tree statuses
    cloned->SetTreeImplementationStatus(tree_statuses_);
 
    return cloned;
}
 
std::shared_ptr<BehaviorTreeProject> BehaviorTreeProject::CreateEmpty(const String &name) {
    return std::make_shared<BehaviorTreeProject>(name);
}
 
int64_t BehaviorTreeProject::GetCurrentTimestamp() {
    auto now = std::chrono::system_clock::now();
    auto duration = now.time_since_epoch();
    return std::chrono::duration_cast<std::chrono::seconds>(duration).count();
}
 
} // namespace EmberCore