BehaviorTreeProjectDialog.cpp

Go to the documentation of this file.

#include "Dialogs/BehaviorTreeProjectDialog.h"
#include "Parsers/BehaviorTreeProject.h"
#include "Parsers/ConfigManager.h"
#include "Parsers/IParseProgressCallback.h"
#include "Parsers/LibXMLBehaviorTreeParser.h"
#include "Parsers/ParserConfig.h"
#include "Parsers/ProjectManager.h"
#include "Utils/Logger.h"
#include "Utils/ResourcePath.h"
#include <cmath>
#include <fstream>
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <sstream>
#include <wx/artprov.h>
#include <wx/dir.h>
#include <wx/dirdlg.h>
#include <wx/filedlg.h>
#include <wx/filename.h>
#include <wx/gbsizer.h>
#include <wx/msgdlg.h>
#include <wx/splitter.h>
#include <wx/statbox.h>
#include <wx/statline.h>
#include <wx/stdpaths.h>
 
// Progress callback for parser validation
class DialogProgressCallback : public EmberCore::IParseProgressCallback {
  public:
    DialogProgressCallback(wxGauge *gauge, wxStaticText *text, wxDialog *dialog)
        : m_gauge(gauge), m_text(text), m_dialog(dialog) {}
 
    bool OnProgress(const EmberCore::String &message, int current, int total) override {
        if (m_gauge && m_text && m_dialog) {
            // Update progress bar
            if (total > 0) {
                int percentage = (current * 100) / total;
                m_gauge->SetValue(percentage);
            }
 
            // Update status text
            m_text->SetLabelText(wxString::FromUTF8(message.c_str()));
 
            // Force UI update
            m_gauge->Update();
            m_text->Update();
            m_dialog->Layout();
            wxYield(); // Process pending events to keep UI responsive
        }
        return true; // Continue parsing
    }
 
  private:
    wxGauge *m_gauge;
    wxStaticText *m_text;
    wxDialog *m_dialog;
};
 
// Static member to remember last used directory across dialog instances
wxString BehaviorTreeProjectDialog::s_lastUsedDirectory;
 
wxBEGIN_EVENT_TABLE(BehaviorTreeProjectDialog,
                    EmberUI::ScalableDialog) EVT_TEXT(ID_PROJECT_NAME, BehaviorTreeProjectDialog::OnProjectNameChanged)
    EVT_TEXT(ID_PROJECT_DESCRIPTION, BehaviorTreeProjectDialog::OnDescriptionChanged)
        EVT_CHOICE(ID_PARSER_PROFILE, BehaviorTreeProjectDialog::OnProfileSelected)
            EVT_BUTTON(ID_ADD_FILES, BehaviorTreeProjectDialog::OnAddFiles)
                EVT_BUTTON(ID_ADD_FOLDER,
                           BehaviorTreeProjectDialog::OnAddFolder) EVT_BUTTON(ID_REMOVE_FILES,
                                                                              BehaviorTreeProjectDialog::OnRemoveFiles)
                    EVT_BUTTON(ID_CLEAR_FILES, BehaviorTreeProjectDialog::OnClearFiles)
                        EVT_LIST_ITEM_SELECTED(ID_RESOURCE_LIST, BehaviorTreeProjectDialog::OnResourceSelected)
                            EVT_LIST_ITEM_ACTIVATED(ID_RESOURCE_LIST, BehaviorTreeProjectDialog::OnResourceActivated)
                                EVT_BUTTON(ID_VALIDATE, BehaviorTreeProjectDialog::OnValidate)
                                    EVT_BUTTON(ID_REFRESH_PREVIEW, BehaviorTreeProjectDialog::OnRefreshPreview)
                                        EVT_BUTTON(ID_CREATE, BehaviorTreeProjectDialog::OnCreate)
                                            EVT_BUTTON(ID_SAVE, BehaviorTreeProjectDialog::OnSave)
                                                EVT_BUTTON(wxID_CANCEL, BehaviorTreeProjectDialog::OnCancel)
                                                    EVT_TIMER(ID_PULSE_TIMER, BehaviorTreeProjectDialog::OnPulseTimer)
                                                        wxEND_EVENT_TABLE()
 
                                                            BehaviorTreeProjectDialog::BehaviorTreeProjectDialog(
                                                                wxWindow *parent,
                                                                std::shared_ptr<EmberCore::BehaviorTreeProject> project)
    : EmberUI::ScalableDialog(parent, wxID_ANY, project ? "Edit BehaviorTree Project" : "New BehaviorTree Project",
                              wxSize(2000, 1400)),
      m_project(project), m_isValid(false), m_isEditMode(project != nullptr), m_validationStale(true),
      m_lastValidatedParserProfile(""), m_resourceImageList(nullptr), m_pulseTimer(nullptr), m_pulsePhase(0.0f),
      m_normalBg(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)), m_highlightBg(255, 250, 150),
      m_selectedItemIndex(-1) {
    // Create project if not editing
    if (!m_project) {
        m_project = std::make_shared<EmberCore::BehaviorTreeProject>("New Project");
    }
 
    CreateLayout();
    LoadProfileList();
 
    if (m_isEditMode) {
        PopulateFromProject();
    }
 
    UpdateCreateButtonState();
 
    // Start the pulse timer for field highlighting
    m_pulseTimer = new wxTimer(this, ID_PULSE_TIMER);
    m_pulseTimer->Start(30); // 30ms = ~33 FPS for smooth pulsing
 
    Centre();
}
 
BehaviorTreeProjectDialog::~BehaviorTreeProjectDialog() {
    if (m_resourceImageList) {
        delete m_resourceImageList;
    }
 
    if (m_pulseTimer) {
        m_pulseTimer->Stop();
        delete m_pulseTimer;
    }
}
 
void BehaviorTreeProjectDialog::CreateLayout() {
    // Outer vertical sizer for main content + progress bar at bottom
    wxBoxSizer *outerSizer = new wxBoxSizer(wxVERTICAL);
 
    // Horizontal sizer for left/right panels
    wxBoxSizer *mainSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Left panel - Project settings (fixed width)
    wxPanel *leftPanel = CreateLeftPanel(this);
    mainSizer->Add(leftPanel, 0, wxEXPAND | wxALL, 5);
 
    // Vertical line separator
    mainSizer->Add(new wxStaticLine(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL), 0,
                   wxEXPAND | wxTOP | wxBOTTOM, 10);
 
    // Right panel - Tabs (expandable)
    wxPanel *rightPanel = CreateRightPanel(this);
    mainSizer->Add(rightPanel, 1, wxEXPAND | wxALL, 5);
 
    // Add main content to outer sizer
    outerSizer->Add(mainSizer, 1, wxEXPAND);
 
    // Add separator line before progress bar
    outerSizer->Add(new wxStaticLine(this), 0, wxEXPAND);
 
    // Progress indicator at very bottom (hidden by default, spans full width)
    wxBoxSizer *progressSizer = new wxBoxSizer(wxVERTICAL);
 
    m_validationProgressText = new wxStaticText(this, wxID_ANY, "");
    m_validationProgressText->SetForegroundColour(wxColour(150, 150, 255));
    wxFont progressFont = m_validationProgressText->GetFont();
    progressFont.SetPointSize(9);
    m_validationProgressText->SetFont(progressFont);
    progressSizer->Add(m_validationProgressText, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, 8);
 
    m_validationProgress = new wxGauge(this, wxID_ANY, 100, wxDefaultPosition, wxSize(-1, 24));
    m_validationProgress->SetValue(0);
    progressSizer->Add(m_validationProgress, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 8);
 
    // Initially hidden
    m_validationProgressText->Hide();
    m_validationProgress->Hide();
 
    outerSizer->Add(progressSizer, 0, wxEXPAND);
 
    SetSizer(outerSizer);
}
 
wxPanel *BehaviorTreeProjectDialog::CreateLeftPanel(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    panel->SetMinSize(wxSize(280, -1));
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    // Project Settings header
    wxStaticText *header = new wxStaticText(panel, wxID_ANY, "Project Settings");
    wxFont headerFont = header->GetFont();
    headerFont.SetPointSize(headerFont.GetPointSize() + 2);
    headerFont.MakeBold();
    header->SetFont(headerFont);
    sizer->Add(header, 0, wxALL, 10);
 
    sizer->Add(new wxStaticLine(panel), 0, wxEXPAND | wxLEFT | wxRIGHT, 10);
    sizer->AddSpacer(10);
 
    // Project Name
    wxStaticText *nameLabel = new wxStaticText(panel, wxID_ANY, "Project Name:");
    sizer->Add(nameLabel, 0, wxLEFT | wxRIGHT, 10);
 
    m_projectName = new wxTextCtrl(panel, ID_PROJECT_NAME, "", wxDefaultPosition, wxDefaultSize);
    m_projectName->SetHint("Enter project name");
    sizer->Add(m_projectName, 0, wxEXPAND | wxALL, 10);
 
    // Description
    wxStaticText *descLabel = new wxStaticText(panel, wxID_ANY, "Description:");
    sizer->Add(descLabel, 0, wxLEFT | wxRIGHT, 10);
 
    m_projectDescription =
        new wxTextCtrl(panel, ID_PROJECT_DESCRIPTION, "", wxDefaultPosition, wxSize(-1, 80), wxTE_MULTILINE);
    m_projectDescription->SetHint("Optional project description");
    sizer->Add(m_projectDescription, 0, wxEXPAND | wxALL, 10);
 
    // Parser Profile
    wxStaticText *profileLabel = new wxStaticText(panel, wxID_ANY, "Parser Profile:");
    sizer->Add(profileLabel, 0, wxLEFT | wxRIGHT, 10);
 
    m_parserProfile = new wxChoice(panel, ID_PARSER_PROFILE);
    sizer->Add(m_parserProfile, 0, wxEXPAND | wxALL, 10);
 
    // Spacer
    sizer->AddStretchSpacer(1);
 
    // Bottom buttons
    sizer->Add(new wxStaticLine(panel), 0, wxEXPAND | wxLEFT | wxRIGHT, 10);
    sizer->AddSpacer(10);
 
    wxBoxSizer *buttonSizer = new wxBoxSizer(wxHORIZONTAL);
 
    if (m_isEditMode) {
        m_createBtn = new wxButton(panel, ID_SAVE, "Save");
    } else {
        m_createBtn = new wxButton(panel, ID_CREATE, "Create Project");
    }
    m_createBtn->SetMinSize(wxSize(120, -1));
    buttonSizer->Add(m_createBtn, 1, wxRIGHT, 5);
 
    m_cancelBtn = new wxButton(panel, wxID_CANCEL, "Cancel");
    m_cancelBtn->SetMinSize(wxSize(80, -1));
    buttonSizer->Add(m_cancelBtn, 0);
 
    sizer->Add(buttonSizer, 0, wxEXPAND | wxALL, 10);
 
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *BehaviorTreeProjectDialog::CreateRightPanel(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    // Notebook with tabs
    m_notebook = new wxNotebook(panel, wxID_ANY);
 
    m_notebook->AddPage(CreateResourcesTab(m_notebook), "Resources");
    m_notebook->AddPage(CreateValidationTab(m_notebook), "Validation");
    m_notebook->AddPage(CreatePreviewTab(m_notebook), "Preview");
    m_notebook->AddPage(CreateBlackboardTab(m_notebook), "Blackboard");
 
    sizer->Add(m_notebook, 1, wxEXPAND | wxALL, 5);
 
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *BehaviorTreeProjectDialog::CreateResourcesTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    // Header
    wxStaticText *header =
        new wxStaticText(panel, wxID_ANY, "Add XML files that contain BehaviorTree definitions for this project.");
    sizer->Add(header, 0, wxALL, 10);
 
    // Resource list with columns
    m_resourceList = new wxListCtrl(panel, ID_RESOURCE_LIST, wxDefaultPosition, wxDefaultSize,
                                    wxLC_REPORT | wxLC_SINGLE_SEL | wxBORDER_SUNKEN);
 
    // Create image list for status icons
    // 0: tick (valid), 1: warning (minor issues), 2: error (invalid), 3: help (references unimplemented)
    m_resourceImageList = new wxImageList(16, 16);
    m_resourceImageList->Add(wxArtProvider::GetBitmap(wxART_TICK_MARK, wxART_LIST, wxSize(16, 16)));
    m_resourceImageList->Add(wxArtProvider::GetBitmap(wxART_WARNING, wxART_LIST, wxSize(16, 16)));
    m_resourceImageList->Add(wxArtProvider::GetBitmap(wxART_ERROR, wxART_LIST, wxSize(16, 16)));
    m_resourceImageList->Add(wxArtProvider::GetBitmap(wxART_HELP, wxART_LIST, wxSize(16, 16))); // Missing references
    m_resourceList->SetImageList(m_resourceImageList, wxIMAGE_LIST_SMALL);
 
    // Add columns
    m_resourceList->InsertColumn(0, "Status", wxLIST_FORMAT_CENTER, 60);
    m_resourceList->InsertColumn(1, "Filename", wxLIST_FORMAT_LEFT, 200);
    m_resourceList->InsertColumn(2, "Path", wxLIST_FORMAT_LEFT, 300);
    m_resourceList->InsertColumn(3, "Trees", wxLIST_FORMAT_CENTER, 60);
 
    sizer->Add(m_resourceList, 1, wxEXPAND | wxALL, 10);
 
    // Buttons row
    wxBoxSizer *buttonSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_addFilesBtn = new wxButton(panel, ID_ADD_FILES, "Add Files...");
    buttonSizer->Add(m_addFilesBtn, 0, wxRIGHT, 5);
 
    m_addFolderBtn = new wxButton(panel, ID_ADD_FOLDER, "Add Folder...");
    buttonSizer->Add(m_addFolderBtn, 0, wxRIGHT, 5);
 
    m_removeFilesBtn = new wxButton(panel, ID_REMOVE_FILES, "Remove Selected");
    m_removeFilesBtn->Enable(false);
    buttonSizer->Add(m_removeFilesBtn, 0, wxRIGHT, 5);
 
    m_clearFilesBtn = new wxButton(panel, ID_CLEAR_FILES, "Clear All");
    buttonSizer->Add(m_clearFilesBtn, 0, wxRIGHT, 5);
 
    buttonSizer->AddStretchSpacer(1);
 
    m_resourceCountLabel = new wxStaticText(panel, wxID_ANY, "0 files");
    buttonSizer->Add(m_resourceCountLabel, 0, wxALIGN_CENTER_VERTICAL);
 
    sizer->Add(buttonSizer, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 10);
 
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *BehaviorTreeProjectDialog::CreateValidationTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    // Status header
    wxBoxSizer *statusSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_validationIcon = new wxStaticBitmap(
        panel, wxID_ANY, wxArtProvider::GetBitmap(wxART_INFORMATION, wxART_MESSAGE_BOX, wxSize(24, 24)));
    statusSizer->Add(m_validationIcon, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    m_validationStatus = new wxStaticText(panel, wxID_ANY, "Click 'Validate' to check project resources");
    wxFont statusFont = m_validationStatus->GetFont();
    statusFont.MakeBold();
    m_validationStatus->SetFont(statusFont);
    statusSizer->Add(m_validationStatus, 1, wxALIGN_CENTER_VERTICAL);
 
    m_validateBtn = new wxButton(panel, ID_VALIDATE, "Validate");
    statusSizer->Add(m_validateBtn, 0, wxALIGN_CENTER_VERTICAL);
 
    sizer->Add(statusSizer, 0, wxEXPAND | wxALL, 10);
 
    sizer->Add(new wxStaticLine(panel), 0, wxEXPAND | wxLEFT | wxRIGHT, 10);
 
    // Validation report
    wxStaticText *reportLabel = new wxStaticText(panel, wxID_ANY, "Validation Report:");
    sizer->Add(reportLabel, 0, wxLEFT | wxRIGHT | wxTOP, 10);
 
    m_validationReport = new wxTextCtrl(panel, wxID_ANY, "", wxDefaultPosition, wxDefaultSize,
                                        wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH2 | wxHSCROLL);
    m_validationReport->SetBackgroundColour(wxColour(45, 45, 45));
    m_validationReport->SetForegroundColour(wxColour(220, 220, 220));
 
    // Use monospace font for report
    wxFont monoFont(10, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    m_validationReport->SetFont(monoFont);
 
    sizer->Add(m_validationReport, 1, wxEXPAND | wxALL, 10);
 
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *BehaviorTreeProjectDialog::CreatePreviewTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    // Header with refresh button
    wxBoxSizer *headerSizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxStaticText *header = new wxStaticText(panel, wxID_ANY, "Project Structure & Preview:");
    headerSizer->Add(header, 1, wxALIGN_CENTER_VERTICAL);
 
    m_refreshPreviewBtn = new wxButton(panel, ID_REFRESH_PREVIEW, "Refresh");
    headerSizer->Add(m_refreshPreviewBtn, 0);
 
    sizer->Add(headerSizer, 0, wxEXPAND | wxALL, 10);
 
    // Filter controls
    wxStaticBox *filterBox = new wxStaticBox(panel, wxID_ANY, "Show:");
    wxStaticBoxSizer *filterSizer = new wxStaticBoxSizer(filterBox, wxHORIZONTAL);
 
    m_showProjectIssuesCheckBox = new wxCheckBox(panel, wxID_ANY, "Project Issues");
    m_showFilesCheckBox = new wxCheckBox(panel, wxID_ANY, "Files");
    m_showTreesCheckBox = new wxCheckBox(panel, wxID_ANY, "Trees");
    m_showBlackboardsCheckBox = new wxCheckBox(panel, wxID_ANY, "Blackboards");
    m_showErrorsCheckBox = new wxCheckBox(panel, wxID_ANY, "File Errors");
    m_showWarningsCheckBox = new wxCheckBox(panel, wxID_ANY, "File Warnings");
 
    // All checked by default
    m_showProjectIssuesCheckBox->SetValue(true);
    m_showFilesCheckBox->SetValue(true);
    m_showTreesCheckBox->SetValue(true);
    m_showBlackboardsCheckBox->SetValue(true);
    m_showErrorsCheckBox->SetValue(true);
    m_showWarningsCheckBox->SetValue(true);
 
    // Bind filter events
    m_showProjectIssuesCheckBox->Bind(wxEVT_CHECKBOX, &BehaviorTreeProjectDialog::OnPreviewFilterChanged, this);
    m_showFilesCheckBox->Bind(wxEVT_CHECKBOX, &BehaviorTreeProjectDialog::OnPreviewFilterChanged, this);
    m_showTreesCheckBox->Bind(wxEVT_CHECKBOX, &BehaviorTreeProjectDialog::OnPreviewFilterChanged, this);
    m_showBlackboardsCheckBox->Bind(wxEVT_CHECKBOX, &BehaviorTreeProjectDialog::OnPreviewFilterChanged, this);
    m_showErrorsCheckBox->Bind(wxEVT_CHECKBOX, &BehaviorTreeProjectDialog::OnPreviewFilterChanged, this);
    m_showWarningsCheckBox->Bind(wxEVT_CHECKBOX, &BehaviorTreeProjectDialog::OnPreviewFilterChanged, this);
 
    filterSizer->Add(m_showProjectIssuesCheckBox, 0, wxALL, 5);
    filterSizer->Add(m_showFilesCheckBox, 0, wxALL, 5);
    filterSizer->Add(m_showTreesCheckBox, 0, wxALL, 5);
    filterSizer->Add(m_showBlackboardsCheckBox, 0, wxALL, 5);
    filterSizer->Add(m_showErrorsCheckBox, 0, wxALL, 5);
    filterSizer->Add(m_showWarningsCheckBox, 0, wxALL, 5);
 
    sizer->Add(filterSizer, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 10);
 
    // Create splitter for two views
    wxSplitterWindow *splitter =
        new wxSplitterWindow(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_3D | wxSP_LIVE_UPDATE);
 
    // Left panel: File structure (clickable)
    wxPanel *leftPanel = new wxPanel(splitter);
    wxBoxSizer *leftSizer = new wxBoxSizer(wxVERTICAL);
 
    wxStaticText *leftLabel = new wxStaticText(leftPanel, wxID_ANY, "Structure (click to view):");
    leftLabel->SetFont(leftLabel->GetFont().Bold());
    leftSizer->Add(leftLabel, 0, wxALL, 5);
 
    m_fileStructurePanel =
        new wxScrolledWindow(leftPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL | wxBORDER_SUNKEN);
    m_fileStructurePanel->SetBackgroundColour(wxColour(45, 45, 45));
    m_fileStructurePanel->SetScrollRate(0, 10);
 
    m_fileStructurePanel->Bind(wxEVT_PAINT, [this](wxPaintEvent &event) {
        wxPaintDC dc(m_fileStructurePanel);
        m_fileStructurePanel->DoPrepareDC(dc);
        DrawFileStructureDiagram(dc);
    });
 
    m_fileStructurePanel->Bind(wxEVT_LEFT_DOWN, &BehaviorTreeProjectDialog::OnStructurePanelClick, this);
 
    leftSizer->Add(m_fileStructurePanel, 1, wxEXPAND | wxALL, 5);
    leftPanel->SetSizer(leftSizer);
 
    // Right panel: XML preview with warning details at bottom
    wxPanel *rightPanel = new wxPanel(splitter);
    wxBoxSizer *rightSizer = new wxBoxSizer(wxVERTICAL);
 
    wxStaticText *rightLabel = new wxStaticText(rightPanel, wxID_ANY, "XML Preview:");
    rightLabel->SetFont(rightLabel->GetFont().Bold());
    rightSizer->Add(rightLabel, 0, wxALL, 5);
 
    // Create a panel to hold both XML preview and warning details
    wxPanel *xmlContainerPanel = new wxPanel(rightPanel);
    wxBoxSizer *xmlContainerSizer = new wxBoxSizer(wxVERTICAL);
 
    m_xmlPreviewPanel =
        new wxStyledTextCtrl(xmlContainerPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_SUNKEN);
 
    // Configure as read-only text viewer with line numbers
    m_xmlPreviewPanel->SetReadOnly(true);
    m_xmlPreviewPanel->SetWrapMode(wxSTC_WRAP_NONE); // No text wrapping
 
    // Set monospace font for all styles
    wxFont monoFont(10, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    m_xmlPreviewPanel->StyleSetFont(wxSTC_STYLE_DEFAULT, monoFont);
 
    // Dark theme colors - set for all styles
    m_xmlPreviewPanel->StyleSetBackground(wxSTC_STYLE_DEFAULT, wxColour(30, 30, 30));
    m_xmlPreviewPanel->StyleSetForeground(wxSTC_STYLE_DEFAULT, wxColour(220, 220, 220));
    m_xmlPreviewPanel->StyleClearAll(); // Apply default style to all styles
 
    // Define custom styles for text coloring (no background change)
    // Style 1: Warning/Error text (bright orange)
    m_xmlPreviewPanel->StyleSetFont(1, monoFont);
    m_xmlPreviewPanel->StyleSetBackground(1, wxColour(30, 30, 30));  // Same as default
    m_xmlPreviewPanel->StyleSetForeground(1, wxColour(255, 140, 0)); // Bright orange
 
    // Style 2: Tree text (bright green)
    m_xmlPreviewPanel->StyleSetFont(2, monoFont);
    m_xmlPreviewPanel->StyleSetBackground(2, wxColour(30, 30, 30));    // Same as default
    m_xmlPreviewPanel->StyleSetForeground(2, wxColour(100, 255, 100)); // Bright green
 
    // Style 3: Blackboard text (purple/magenta)
    m_xmlPreviewPanel->StyleSetFont(3, monoFont);
    m_xmlPreviewPanel->StyleSetBackground(3, wxColour(30, 30, 30));    // Same as default
    m_xmlPreviewPanel->StyleSetForeground(3, wxColour(200, 130, 255)); // Purple/magenta
 
    // Set caret (cursor) color
    m_xmlPreviewPanel->SetCaretForeground(wxColour(220, 220, 220));
    m_xmlPreviewPanel->SetCaretLineVisible(false); // Don't highlight current line
 
    // Set selection colors
    m_xmlPreviewPanel->SetSelectionMode(wxSTC_SEL_STREAM);
    m_xmlPreviewPanel->SetSelBackground(true, wxColour(60, 90, 140));   // Blue selection background
    m_xmlPreviewPanel->SetSelForeground(true, wxColour(255, 255, 255)); // White selection text
 
    // Line numbers margin
    m_xmlPreviewPanel->SetMarginType(0, wxSTC_MARGIN_NUMBER);
    m_xmlPreviewPanel->SetMarginWidth(0, 50); // Width for line numbers
    m_xmlPreviewPanel->StyleSetBackground(wxSTC_STYLE_LINENUMBER, wxColour(40, 40, 40));
    m_xmlPreviewPanel->StyleSetForeground(wxSTC_STYLE_LINENUMBER, wxColour(120, 120, 120));
 
    // Disable other margins
    m_xmlPreviewPanel->SetMarginWidth(1, 0); // No symbol margin
    m_xmlPreviewPanel->SetMarginWidth(2, 0); // No fold margin
 
    // Set initial text
    m_xmlPreviewPanel->SetText("Click an item to preview XML content");
 
    xmlContainerSizer->Add(m_xmlPreviewPanel, 1, wxEXPAND);
 
    // Warning details panel at the bottom (initially hidden)
    m_warningDetailsPanel = new wxTextCtrl(xmlContainerPanel, wxID_ANY, "", wxDefaultPosition, wxSize(-1, 180),
                                           wxTE_MULTILINE | wxTE_READONLY | wxTE_WORDWRAP | wxBORDER_SUNKEN);
    m_warningDetailsPanel->SetBackgroundColour(wxColour(60, 40, 30));
    m_warningDetailsPanel->SetForegroundColour(wxColour(255, 200, 100));
    wxFont warningFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    m_warningDetailsPanel->SetFont(warningFont);
    m_warningDetailsPanel->Hide(); // Initially hidden
 
    xmlContainerSizer->Add(m_warningDetailsPanel, 0, wxEXPAND);
    xmlContainerPanel->SetSizer(xmlContainerSizer);
 
    rightSizer->Add(xmlContainerPanel, 1, wxEXPAND | wxALL, 5);
    rightPanel->SetSizer(rightSizer);
 
    // Split the view 25/75 (structure gets 25%, preview gets 75%)
    splitter->SplitVertically(leftPanel, rightPanel);
    splitter->SetSashGravity(0.25);
    splitter->SetMinimumPaneSize(20); // Small minimum so we can control the split
 
    // Set initial sash position to 25% of the width
    // We'll set it after the window is shown, so bind to the size event
    splitter->Bind(wxEVT_SIZE, [splitter](wxSizeEvent &event) {
        int width = splitter->GetSize().GetWidth();
        splitter->SetSashPosition(static_cast<int>(width * 0.25));
        event.Skip();
    });
 
    // Make splitter non-movable by preventing sash position changes
    splitter->Bind(wxEVT_SPLITTER_SASH_POS_CHANGING, [](wxSplitterEvent &event) {
        event.Veto(); // Prevent sash from being moved
    });
 
    sizer->Add(splitter, 1, wxEXPAND | wxLEFT | wxRIGHT, 10);
 
    // Tree count label
    m_treeCountLabel = new wxStaticText(panel, wxID_ANY, "No trees loaded");
    sizer->Add(m_treeCountLabel, 0, wxALL, 10);
 
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *BehaviorTreeProjectDialog::CreateBlackboardTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    // Header
    wxStaticText *header = new wxStaticText(panel, wxID_ANY, "Blackboard Overview:");
    header->SetFont(header->GetFont().Bold());
    sizer->Add(header, 0, wxALL, 10);
 
    // Scrollable panel for blackboard table-cards
    m_blackboardPanel = new wxScrolledWindow(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize,
                                             wxVSCROLL | wxHSCROLL | wxBORDER_SUNKEN);
    m_blackboardPanel->SetBackgroundColour(wxColour(40, 40, 40));
    m_blackboardPanel->SetScrollRate(10, 10);
 
    m_blackboardPanel->Bind(wxEVT_PAINT, [this](wxPaintEvent &event) {
        wxPaintDC dc(m_blackboardPanel);
        m_blackboardPanel->DoPrepareDC(dc);
        DrawBlackboardDiagram(dc);
    });
 
    sizer->Add(m_blackboardPanel, 1, wxEXPAND | wxALL, 5);
 
    panel->SetSizer(sizer);
    return panel;
}
 
void BehaviorTreeProjectDialog::UpdateBlackboardTab() {
    if (m_blackboardPanel) {
        m_blackboardPanel->Refresh();
    }
}
 
void BehaviorTreeProjectDialog::DrawBlackboardDiagram(wxDC &dc) {
    dc.SetBackground(wxBrush(wxColour(40, 40, 40)));
    dc.Clear();
 
    if (!m_lastValidationReport) {
        dc.SetTextForeground(wxColour(150, 150, 150));
        dc.SetFont(wxFont(11, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_NORMAL));
        dc.DrawText("Run validation to see blackboard data", 20, 20);
        return;
    }
 
    const auto &report = *m_lastValidationReport;
 
    int x = 15;
    int y = 10;
    int panelWidth = m_blackboardPanel->GetClientSize().GetWidth();
    if (panelWidth < 300)
        panelWidth = 600;
    int contentWidth = panelWidth - 30;
 
    // --- Summary Box ---
    {
        int summaryHeight = 80;
        dc.SetBrush(wxBrush(wxColour(50, 50, 60)));
        dc.SetPen(wxPen(wxColour(100, 130, 200), 1));
        dc.DrawRoundedRectangle(x, y, contentWidth, summaryHeight, 5);
 
        dc.SetTextForeground(wxColour(130, 180, 255));
        dc.SetFont(wxFont(11, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
        dc.DrawText("Blackboard Summary", x + 10, y + 8);
 
        // Collect counts
        int totalBBs = 0, totalFiles = 0;
        for (const auto &rs : report.resource_statuses) {
            if (rs.has_blackboards) {
                totalFiles++;
                totalBBs += rs.blackboard_count;
            }
        }
 
        dc.SetFont(wxFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        dc.SetTextForeground(wxColour(200, 200, 200));
        dc.DrawText(wxString::Format("Total Blackboards: %d across %d file(s)", totalBBs, totalFiles), x + 15, y + 30);
 
        if (!report.unresolved_blackboard_includes.empty()) {
            dc.SetTextForeground(wxColour(255, 180, 50));
            wxString unresolvedStr = "Unresolved includes: ";
            for (size_t i = 0; i < report.unresolved_blackboard_includes.size(); ++i) {
                if (i > 0)
                    unresolvedStr += ", ";
                unresolvedStr += report.unresolved_blackboard_includes[i];
            }
            dc.DrawText(unresolvedStr, x + 15, y + 50);
        } else {
            dc.SetTextForeground(wxColour(100, 255, 100));
            dc.DrawText("All blackboard includes resolved", x + 15, y + 50);
        }
 
        y += summaryHeight + 15;
    }
 
    // --- Per-file blackboard tables ---
    // We need to re-parse files to get entry details since validation only stores IDs
    for (const auto &rs : report.resource_statuses) {
        if (!rs.has_blackboards)
            continue;
 
        // File header bar
        wxFileName fn(wxString::FromUTF8(rs.filepath));
        wxString filename = fn.GetFullName();
 
        dc.SetBrush(wxBrush(wxColour(60, 50, 70)));
        dc.SetPen(wxPen(wxColour(150, 100, 200), 1));
        dc.DrawRoundedRectangle(x, y, contentWidth, 28, 4);
 
        dc.SetTextForeground(wxColour(200, 160, 255));
        dc.SetFont(wxFont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
        dc.DrawText(filename, x + 10, y + 5);
 
        dc.SetTextForeground(wxColour(150, 150, 150));
        dc.SetFont(wxFont(8, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
        wxString countStr = wxString::Format("(%d blackboard(s))", rs.blackboard_count);
        dc.DrawText(countStr, x + contentWidth - 130, y + 7);
 
        y += 35;
 
        // Parse the XML to get entry details
        std::string resolvedPath = m_project->ResolveResourcePath(rs.filepath);
        xmlDocPtr doc = xmlReadFile(resolvedPath.c_str(), nullptr, XML_PARSE_NOERROR | XML_PARSE_NOWARNING);
        if (!doc) {
            dc.SetTextForeground(wxColour(255, 100, 100));
            dc.DrawText("Could not parse file for blackboard details", x + 20, y);
            y += 25;
            continue;
        }
 
        xmlNodePtr root = xmlDocGetRootElement(doc);
        if (!root) {
            xmlFreeDoc(doc);
            continue;
        }
 
        for (xmlNodePtr child = root->children; child; child = child->next) {
            if (child->type != XML_ELEMENT_NODE)
                continue;
            const char *nodeName = reinterpret_cast<const char *>(child->name);
            if (!nodeName || strcmp(nodeName, "Blackboard") != 0)
                continue;
 
            // Get blackboard ID
            std::string bbId;
            xmlChar *idAttr = xmlGetProp(child, reinterpret_cast<const xmlChar *>("ID"));
            if (idAttr) {
                bbId = reinterpret_cast<const char *>(idAttr);
                xmlFree(idAttr);
            }
 
            // Get includes
            std::string includesStr;
            xmlChar *incAttr = xmlGetProp(child, reinterpret_cast<const xmlChar *>("includes"));
            if (incAttr) {
                includesStr = reinterpret_cast<const char *>(incAttr);
                xmlFree(incAttr);
            }
 
            // Collect entries
            struct BBEntry {
                std::string key, type, value;
            };
            std::vector<BBEntry> entries;
            for (xmlNodePtr entryNode = child->children; entryNode; entryNode = entryNode->next) {
                if (entryNode->type != XML_ELEMENT_NODE)
                    continue;
                const char *eName = reinterpret_cast<const char *>(entryNode->name);
                if (!eName || strcmp(eName, "Entry") != 0)
                    continue;
 
                BBEntry e;
                xmlChar *keyA = xmlGetProp(entryNode, reinterpret_cast<const xmlChar *>("key"));
                if (keyA) {
                    e.key = reinterpret_cast<const char *>(keyA);
                    xmlFree(keyA);
                }
                xmlChar *typeA = xmlGetProp(entryNode, reinterpret_cast<const xmlChar *>("type"));
                if (typeA) {
                    e.type = reinterpret_cast<const char *>(typeA);
                    xmlFree(typeA);
                }
                xmlChar *valA = xmlGetProp(entryNode, reinterpret_cast<const xmlChar *>("value"));
                if (valA) {
                    e.value = reinterpret_cast<const char *>(valA);
                    xmlFree(valA);
                }
                entries.push_back(e);
            }
 
            // --- Draw blackboard card ---
            // Card header
            int cardHeaderH = 26;
            dc.SetBrush(wxBrush(wxColour(70, 50, 90)));
            dc.SetPen(wxPen(wxColour(150, 100, 200), 1));
            dc.DrawRoundedRectangle(x + 10, y, contentWidth - 20, cardHeaderH, 3);
 
            dc.SetTextForeground(wxColour(220, 180, 255));
            dc.SetFont(wxFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
            wxString headerText = wxString::Format("[%s] (%zu entries)", bbId, entries.size());
            dc.DrawText(headerText, x + 20, y + 4);
 
            if (!includesStr.empty()) {
                dc.SetTextForeground(wxColour(180, 150, 200));
                dc.SetFont(wxFont(8, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
                wxString incText = "includes: " + wxString::FromUTF8(includesStr);
                // Truncate if too long
                int maxW = contentWidth - 200;
                wxSize ext = dc.GetTextExtent(incText);
                if (ext.GetWidth() > maxW && maxW > 0) {
                    while (dc.GetTextExtent(incText + "...").GetWidth() > maxW && incText.Length() > 10) {
                        incText = incText.Left(incText.Length() - 1);
                    }
                    incText += "...";
                }
                dc.DrawText(incText, x + contentWidth - 180, y + 6);
            }
 
            y += cardHeaderH + 2;
 
            // Table header row
            int rowH = 20;
            int col1W = (contentWidth - 40) * 45 / 100;      // Key: 45%
            int col2W = (contentWidth - 40) * 25 / 100;      // Type: 25%
            int col3W = (contentWidth - 40) - col1W - col2W; // Value: rest
            int tableX = x + 15;
 
            dc.SetBrush(wxBrush(wxColour(55, 55, 65)));
            dc.SetPen(wxPen(wxColour(80, 80, 100), 1));
            dc.DrawRectangle(tableX, y, col1W, rowH);
            dc.DrawRectangle(tableX + col1W, y, col2W, rowH);
            dc.DrawRectangle(tableX + col1W + col2W, y, col3W, rowH);
 
            dc.SetTextForeground(wxColour(180, 180, 220));
            dc.SetFont(wxFont(8, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
            dc.DrawText("Key", tableX + 5, y + 3);
            dc.DrawText("Type", tableX + col1W + 5, y + 3);
            dc.DrawText("Value", tableX + col1W + col2W + 5, y + 3);
 
            y += rowH;
 
            // Table rows
            dc.SetFont(wxFont(8, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
            for (size_t ei = 0; ei < entries.size(); ++ei) {
                const auto &e = entries[ei];
 
                // Alternating row colors
                wxColour rowBg = (ei % 2 == 0) ? wxColour(45, 45, 50) : wxColour(50, 50, 55);
                dc.SetBrush(wxBrush(rowBg));
                dc.SetPen(wxPen(wxColour(60, 60, 70), 1));
                dc.DrawRectangle(tableX, y, col1W, rowH);
                dc.DrawRectangle(tableX + col1W, y, col2W, rowH);
                dc.DrawRectangle(tableX + col1W + col2W, y, col3W, rowH);
 
                // Truncate text helper
                auto truncate = [&dc](const wxString &text, int maxWidth) -> wxString {
                    wxString result = text;
                    if (dc.GetTextExtent(result).GetWidth() > maxWidth && maxWidth > 0) {
                        while (dc.GetTextExtent(result + "...").GetWidth() > maxWidth && result.Length() > 1) {
                            result = result.Left(result.Length() - 1);
                        }
                        result += "...";
                    }
                    return result;
                };
 
                dc.SetTextForeground(wxColour(200, 200, 200));
                dc.DrawText(truncate(wxString::FromUTF8(e.key), col1W - 10), tableX + 5, y + 3);
 
                dc.SetTextForeground(wxColour(150, 200, 180));
                dc.DrawText(truncate(wxString::FromUTF8(e.type), col2W - 10), tableX + col1W + 5, y + 3);
 
                dc.SetTextForeground(wxColour(180, 180, 150));
                dc.DrawText(truncate(wxString::FromUTF8(e.value), col3W - 10), tableX + col1W + col2W + 5, y + 3);
 
                y += rowH;
            }
 
            y += 10; // Space between blackboard cards
        }
 
        xmlFreeDoc(doc);
        y += 10; // Space between files
    }
 
    // If no blackboards found
    if (y < 100) {
        dc.SetTextForeground(wxColour(150, 150, 150));
        dc.SetFont(wxFont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_NORMAL));
        dc.DrawText("No blackboards found in project files", 20, y);
        y += 30;
    }
 
    // Set virtual size for scrolling
    m_blackboardPanel->SetVirtualSize(panelWidth, y + 20);
}
 
void BehaviorTreeProjectDialog::LoadProfileList() {
    m_parserProfile->Clear();
 
    auto &configManager = EmberCore::ConfigManager::GetInstance();
    auto profileNames = configManager.GetProfileNames();
 
    for (const auto &name : profileNames) {
        m_parserProfile->Append(wxString::FromUTF8(name));
    }
 
    // Select the project's profile or the active profile
    wxString profileToSelect = wxString::FromUTF8(m_project->GetParserProfileName());
    int index = m_parserProfile->FindString(profileToSelect);
    if (index == wxNOT_FOUND) {
        profileToSelect = wxString::FromUTF8(configManager.GetActiveProfileName());
        index = m_parserProfile->FindString(profileToSelect);
    }
 
    if (index != wxNOT_FOUND) {
        m_parserProfile->SetSelection(index);
    } else if (m_parserProfile->GetCount() > 0) {
        m_parserProfile->SetSelection(0);
    }
}
 
void BehaviorTreeProjectDialog::PopulateFromProject() {
    m_projectName->SetValue(wxString::FromUTF8(m_project->GetName()));
    m_projectDescription->SetValue(wxString::FromUTF8(m_project->GetDescription()));
 
    // Set parser profile
    wxString profileName = wxString::FromUTF8(m_project->GetParserProfileName());
    int index = m_parserProfile->FindString(profileName);
    if (index != wxNOT_FOUND) {
        m_parserProfile->SetSelection(index);
    }
 
    // Update resource list
    UpdateResourceList();
 
    // Defer validation until after the dialog is visible
    // This way the dialog opens instantly and users see the progress bar
    CallAfter([this]() { ValidateAndUpdateUI(); });
}
 
void BehaviorTreeProjectDialog::UpdateResourceList() {
    m_resourceList->DeleteAllItems();
 
    const auto &resources = m_project->GetResources();
 
    for (size_t i = 0; i < resources.size(); ++i) {
        const auto &resource = resources[i];
        wxFileName fn(wxString::FromUTF8(resource));
 
        long item = m_resourceList->InsertItem(i, "");
        m_resourceList->SetItem(item, 1, fn.GetFullName());
        m_resourceList->SetItem(item, 2, fn.GetPath());
        m_resourceList->SetItem(item, 3, "?");
 
        // Default to unknown status
        m_resourceList->SetItemImage(item, 1); // Warning icon
    }
 
    // Update count label
    m_resourceCountLabel->SetLabel(wxString::Format("%zu file(s)", resources.size()));
    m_clearFilesBtn->Enable(!resources.empty());
}
 
void BehaviorTreeProjectDialog::OnProjectNameChanged(wxCommandEvent &event) {
    m_project->SetName(m_projectName->GetValue().ToStdString());
    UpdateCreateButtonState();
}
 
void BehaviorTreeProjectDialog::OnDescriptionChanged(wxCommandEvent &event) {
    m_project->SetDescription(m_projectDescription->GetValue().ToStdString());
}
 
void BehaviorTreeProjectDialog::OnProfileSelected(wxCommandEvent &event) {
    int sel = m_parserProfile->GetSelection();
    if (sel != wxNOT_FOUND) {
        wxString selectedProfile = m_parserProfile->GetString(sel);
        m_project->SetParserProfileName(selectedProfile.ToStdString());
 
        // Mark validation as stale if profile changed
        if (!m_lastValidatedParserProfile.IsEmpty() && m_lastValidatedParserProfile != selectedProfile) {
            m_validationStale = true;
 
            // Update validation status to notify user
            m_validationStatus->SetLabel("Parser profile changed - click 'Validate' to revalidate");
            m_validationStatus->SetForegroundColour(wxColour(255, 200, 100));
            m_validationIcon->SetBitmap(wxArtProvider::GetBitmap(wxART_INFORMATION, wxART_MESSAGE_BOX, wxSize(24, 24)));
        }
    }
}
 
void BehaviorTreeProjectDialog::OnAddFiles(wxCommandEvent &event) {
    // Determine the initial directory
    wxString initialDir = s_lastUsedDirectory;
 
    // If no last directory, try to use the project's directory or default to resources folder
    if (initialDir.IsEmpty()) {
        if (!m_project->GetProjectFilePath().empty()) {
            wxFileName projectPath(wxString::FromUTF8(m_project->GetProjectFilePath()));
            initialDir = projectPath.GetPath();
        }
        if (initialDir.IsEmpty()) {
            // Default to resources folder
            initialDir = EmberForge::ResourcePath::GetResourcesDir();
 
            // Fallback to home if resources doesn't exist
            if (initialDir.IsEmpty() || !wxFileName::DirExists(initialDir)) {
                initialDir = wxGetHomeDir();
            }
        }
    }
 
    wxFileDialog openFileDialog(
        this, "Add Resource Files (Tip: Use Shift+Click or Right Ctrl+Click for multi-selection)", initialDir, "",
        "All files (*.*)|*.*|XML files (*.xml)|*.xml", wxFD_OPEN | wxFD_FILE_MUST_EXIST | wxFD_MULTIPLE);
 
    if (openFileDialog.ShowModal() == wxID_CANCEL) {
        return;
    }
 
    // Remember the directory for next time
    s_lastUsedDirectory = openFileDialog.GetDirectory();
 
    wxArrayString paths;
    openFileDialog.GetPaths(paths);
 
    int addedCount = 0;
    int duplicateCount = 0;
 
    for (const auto &path : paths) {
        std::string pathStr = path.ToStdString();
 
        // Store relative path if project has a file path
        if (!m_project->GetProjectFilePath().empty()) {
            pathStr = m_project->MakeRelativePath(pathStr);
        }
 
        // Check if already added (AddResource returns false for duplicates)
        if (m_project->AddResource(pathStr)) {
            addedCount++;
        } else {
            duplicateCount++;
        }
    }
 
    // Notify user about duplicates
    if (duplicateCount > 0) {
        wxString msg = wxString::Format("%d file(s) added. %d file(s) were already in the project and skipped.",
                                        addedCount, duplicateCount);
        wxMessageBox(msg, "Files Added", wxOK | wxICON_INFORMATION, this);
    }
 
    UpdateResourceList();
    ValidateAndUpdateUI();
}
 
void BehaviorTreeProjectDialog::OnAddFolder(wxCommandEvent &event) {
    wxString initialDir = s_lastUsedDirectory;
 
    if (initialDir.IsEmpty()) {
        if (!m_project->GetProjectFilePath().empty()) {
            wxFileName projectPath(wxString::FromUTF8(m_project->GetProjectFilePath()));
            initialDir = projectPath.GetPath();
        }
        if (initialDir.IsEmpty()) {
            initialDir = EmberForge::ResourcePath::GetResourcesDir();
            if (initialDir.IsEmpty() || !wxFileName::DirExists(initialDir)) {
                initialDir = wxGetHomeDir();
            }
        }
    }
 
    wxDirDialog dirDialog(this, "Select folder to add XML files recursively", initialDir,
                          wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
 
    if (dirDialog.ShowModal() == wxID_CANCEL)
        return;
 
    wxString selectedDir = dirDialog.GetPath();
    s_lastUsedDirectory = selectedDir;
 
    wxArrayString xmlFiles;
    wxDir::GetAllFiles(selectedDir, &xmlFiles, "*.xml", wxDIR_FILES | wxDIR_DIRS);
 
    if (xmlFiles.IsEmpty()) {
        wxMessageBox("No XML files found in the selected folder or its subfolders.", "No Files Found",
                     wxOK | wxICON_INFORMATION, this);
        return;
    }
 
    int addedCount = 0;
    int duplicateCount = 0;
 
    for (const auto &path : xmlFiles) {
        std::string pathStr = path.ToStdString();
 
        if (!m_project->GetProjectFilePath().empty()) {
            pathStr = m_project->MakeRelativePath(pathStr);
        }
 
        if (m_project->AddResource(pathStr)) {
            addedCount++;
        } else {
            duplicateCount++;
        }
    }
 
    wxString msg;
    if (duplicateCount > 0) {
        msg = wxString::Format("%d XML file(s) added from folder. %d file(s) were already in the project and skipped.",
                               addedCount, duplicateCount);
    } else {
        msg = wxString::Format("%d XML file(s) added from folder and subfolders.", addedCount);
    }
    wxMessageBox(msg, "Folder Added", wxOK | wxICON_INFORMATION, this);
 
    UpdateResourceList();
    ValidateAndUpdateUI();
}
 
void BehaviorTreeProjectDialog::OnRemoveFiles(wxCommandEvent &event) {
    long item = m_resourceList->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    if (item == -1) {
        return;
    }
 
    const auto &resources = m_project->GetResources();
    if (item < static_cast<long>(resources.size())) {
        m_project->RemoveResource(resources[item]);
        UpdateResourceList();
        ValidateAndUpdateUI();
    }
 
    m_removeFilesBtn->Enable(false);
}
 
void BehaviorTreeProjectDialog::OnClearFiles(wxCommandEvent &event) {
    int result = wxMessageBox("Remove all files from the project?", "Confirm", wxYES_NO | wxICON_QUESTION, this);
    if (result == wxYES) {
        m_project->ClearResources();
        UpdateResourceList();
        ValidateAndUpdateUI();
    }
}
 
void BehaviorTreeProjectDialog::OnResourceSelected(wxListEvent &event) { m_removeFilesBtn->Enable(true); }
 
void BehaviorTreeProjectDialog::OnResourceActivated(wxListEvent &event) {
    // Double-click on resource: switch to Preview tab and show the file
    long item = event.GetIndex();
    const auto &resources = m_project->GetResources();
 
    if (item >= static_cast<long>(resources.size())) {
        return;
    }
 
    std::string resourcePath = resources[item];
 
    // Switch to Preview tab (index 2: Resources=0, Validation=1, Preview=2)
    if (m_notebook) {
        m_notebook->SetSelection(2);
    }
 
    // Find this file in the clickable items and select it
    for (size_t i = 0; i < m_clickableItems.size(); ++i) {
        const auto &clickItem = m_clickableItems[i];
        if (clickItem.type == ClickableItem::File && clickItem.filepath == resourcePath) {
            // Found it! Select and load preview
            m_selectedItemIndex = static_cast<int>(i);
 
            // Smart scroll: Scroll the structure panel to show the selected item
            if (m_fileStructurePanel) {
                wxRect itemRect = clickItem.rect;
                int scrollUnitY;
                m_fileStructurePanel->GetScrollPixelsPerUnit(nullptr, &scrollUnitY);
 
                if (scrollUnitY > 0) {
                    // Get visible area
                    wxSize clientSize = m_fileStructurePanel->GetClientSize();
                    int viewStartX, viewStartY;
                    m_fileStructurePanel->GetViewStart(&viewStartX, &viewStartY);
                    int visibleTop = viewStartY * scrollUnitY;
                    int visibleBottom = visibleTop + clientSize.GetHeight();
 
                    // Check if item is not fully visible
                    if (itemRect.GetTop() < visibleTop || itemRect.GetBottom() > visibleBottom) {
                        // Scroll to center the item
                        int targetY = itemRect.GetTop() - (clientSize.GetHeight() / 2) + (itemRect.GetHeight() / 2);
                        if (targetY < 0)
                            targetY = 0;
                        m_fileStructurePanel->Scroll(0, targetY / scrollUnitY);
                    }
                }
            }
 
            m_fileStructurePanel->Refresh();
            LoadXMLPreview(clickItem.filepath);
            m_warningDetailsPanel->Hide();
            m_warningDetailsPanel->GetParent()->Layout();
            return;
        }
    }
 
    // If not found in clickable items, just load the XML directly
    LoadXMLPreview(m_project->ResolveResourcePath(resourcePath));
    m_warningDetailsPanel->Hide();
    m_warningDetailsPanel->GetParent()->Layout();
}
 
void BehaviorTreeProjectDialog::OnValidate(wxCommandEvent &event) { ValidateAndUpdateUI(); }
 
void BehaviorTreeProjectDialog::OnRefreshPreview(wxCommandEvent &event) { UpdateTreePreview(); }
 
void BehaviorTreeProjectDialog::OnPreviewFilterChanged(wxCommandEvent &event) {
    // Redraw the preview with new filters
    if (m_fileStructurePanel) {
        m_fileStructurePanel->Refresh();
    }
}
 
void BehaviorTreeProjectDialog::ValidateAndUpdateUI() {
    wxString currentProfile = m_parserProfile->GetStringSelection();
 
    // Show progress UI
    m_validationProgress->Show();
    m_validationProgressText->Show();
    m_validationProgress->SetValue(0);
    m_validationProgressText->SetLabelText("Initializing parser...");
    m_validateBtn->Enable(false);
    Layout();
    Update();
    wxYield();
 
    EmberCore::ProjectValidationReport report;
 
    // Create parser with selected profile
    std::string profileName = currentProfile.ToStdString();
    auto &configManager = EmberCore::ConfigManager::GetInstance();
    auto profile = configManager.GetProfile(profileName);
 
    EmberCore::ParserConfig parserConfig;
    if (profile) {
        parserConfig = profile->GetConfig();
    } else {
        // Fallback to default profile
        LOG_WARNING("BehaviorTreeProjectDialog", "Failed to load parser profile, using default config");
    }
 
    // Create parser instance
    auto parser = std::make_unique<EmberCore::LibXMLBehaviorTreeParser>(parserConfig);
 
    // Set progress callback
    DialogProgressCallback progressCallback(m_validationProgress, m_validationProgressText, this);
    parser->SetProgressCallback(&progressCallback);
 
    // Run parser-based validation
    report = m_project->ValidateWithParser(parser.get());
 
    // Store result
    m_lastValidationReport = std::make_unique<EmberCore::ProjectValidationReport>(report);
    m_validationStale = false;
    m_lastValidatedParserProfile = currentProfile;
 
    // Build a map of which files reference unimplemented trees
    std::set<EmberCore::String> files_with_unimpl_refs;
    for (const auto &tree_id : report.unimplemented_trees) {
        auto it = report.tree_statuses.find(tree_id);
        if (it != report.tree_statuses.end()) {
            for (const auto &file : it->second.referenced_in_files) {
                files_with_unimpl_refs.insert(file);
            }
        }
    }
 
    // Update resource list with status
    const auto &resources = m_project->GetResources();
    for (size_t i = 0; i < report.resource_statuses.size() && i < resources.size(); ++i) {
        const auto &status = report.resource_statuses[i];
 
        int imageIndex;
        if (!status.IsValid()) {
            // File has errors (invalid XML, not found, etc.)
            imageIndex = status.exists ? 1 : 2; // warning or error
        } else if (files_with_unimpl_refs.find(resources[i]) != files_with_unimpl_refs.end()) {
            // File is valid but references unimplemented trees
            imageIndex = 3; // help/question icon
        } else {
            // File is valid and all references are implemented
            imageIndex = 0; // tick
        }
 
        m_resourceList->SetItemImage(i, imageIndex);
        m_resourceList->SetItem(i, 3, wxString::Format("%d", status.tree_count));
    }
 
    // Update validation status
    if (report.is_valid) {
        if (!report.unimplemented_trees.empty()) {
            m_validationStatus->SetLabel("Validation passed with warnings");
            m_validationStatus->SetForegroundColour(wxColour(255, 180, 50));
            m_validationIcon->SetBitmap(wxArtProvider::GetBitmap(wxART_WARNING, wxART_MESSAGE_BOX, wxSize(24, 24)));
        } else {
            m_validationStatus->SetLabel("Validation passed");
            m_validationStatus->SetForegroundColour(wxColour(100, 200, 100));
            m_validationIcon->SetBitmap(wxArtProvider::GetBitmap(wxART_TICK_MARK, wxART_MESSAGE_BOX, wxSize(24, 24)));
        }
    } else {
        m_validationStatus->SetLabel("Validation failed - see report for details");
        m_validationStatus->SetForegroundColour(wxColour(255, 100, 100));
        m_validationIcon->SetBitmap(wxArtProvider::GetBitmap(wxART_ERROR, wxART_MESSAGE_BOX, wxSize(24, 24)));
    }
 
    // Generate and display report with color coding
    GenerateColoredValidationReport(report);
 
    m_isValid = report.is_valid;
    UpdateCreateButtonState();
 
    // Update preview
    UpdateTreePreview();
 
    // Update blackboard tab
    UpdateBlackboardTab();
 
    // Hide progress UI
    m_validationProgress->Hide();
    m_validationProgressText->Hide();
    m_validateBtn->Enable(true);
    Layout();
}
 
void BehaviorTreeProjectDialog::GenerateColoredValidationReport(const EmberCore::ProjectValidationReport &report) {
    m_validationReport->Clear();
 
    // Define colors
    wxColour headerColor(100, 200, 255);  // Light blue for headers
    wxColour successColor(100, 255, 100); // Green for success/OK
    wxColour warningColor(255, 200, 50);  // Yellow/orange for warnings
    wxColour errorColor(255, 100, 100);   // Red for errors
    wxColour infoColor(180, 180, 180);    // Light gray for info
    wxColour defaultColor(220, 220, 220); // Default text color
 
    // Helper lambda to append colored text
    auto AppendColored = [this](const wxString &text, const wxColour &color) {
        wxTextAttr style;
        style.SetTextColour(color);
        m_validationReport->SetDefaultStyle(style);
        m_validationReport->AppendText(text);
    };
 
    // Header
    AppendColored("=== BehaviorTree Project Validation Report ===\n\n", headerColor);
 
    // File count
    AppendColored(wxString::Format("Files: %zu XML files\n\n", report.resource_statuses.size()), infoColor);
 
    // Valid files section
    int valid_count = report.GetValidFileCount();
    AppendColored(wxString::Format("VALID FILES (%d):\n", valid_count), successColor);
    for (const auto &status : report.resource_statuses) {
        if (status.IsValid()) {
            AppendColored("  [OK] ", successColor);
            AppendColored(wxString::FromUTF8(status.filepath.c_str()), defaultColor);
            AppendColored(wxString::Format(" (%d trees)\n", status.tree_count), infoColor);
        }
    }
    AppendColored("\n", defaultColor);
 
    // Invalid files section
    int invalid_count = static_cast<int>(report.resource_statuses.size()) - valid_count;
    if (invalid_count > 0) {
        AppendColored(wxString::Format("INVALID FILES (%d):\n", invalid_count), errorColor);
        for (const auto &status : report.resource_statuses) {
            if (!status.IsValid()) {
                AppendColored("  [ERROR] ", errorColor);
                AppendColored(wxString::FromUTF8(status.filepath.c_str()) + "\n", defaultColor);
                for (const auto &err : status.errors) {
                    AppendColored("    - ", errorColor);
                    AppendColored(wxString::FromUTF8(err.c_str()) + "\n", defaultColor);
                }
            }
        }
        AppendColored("\n", defaultColor);
    }
 
    // Warnings section
    if (!report.warnings.empty() || !report.unimplemented_trees.empty()) {
        AppendColored(wxString::Format("WARNINGS (%d):\n",
                                       static_cast<int>(report.warnings.size() + report.unimplemented_trees.size())),
                      warningColor);
        for (const auto &warn : report.warnings) {
            AppendColored("  [WARN] ", warningColor);
            AppendColored(wxString::FromUTF8(warn.c_str()) + "\n", defaultColor);
        }
        for (const auto &tree : report.unimplemented_trees) {
            AppendColored("  [WARN] ", warningColor);
            AppendColored("Tree '", defaultColor);
            AppendColored(wxString::FromUTF8(tree.c_str()), warningColor);
            AppendColored("' is referenced but not implemented\n", defaultColor);
        }
        AppendColored("\n", defaultColor);
    }
 
    // Errors section
    if (!report.errors.empty() || !report.circular_references.empty()) {
        AppendColored(wxString::Format("ERRORS (%d):\n",
                                       static_cast<int>(report.errors.size() + report.circular_references.size())),
                      errorColor);
        for (const auto &err : report.errors) {
            AppendColored("  [ERROR] ", errorColor);
            AppendColored(wxString::FromUTF8(err.c_str()) + "\n", defaultColor);
        }
        for (const auto &ref : report.circular_references) {
            AppendColored("  [ERROR] ", errorColor);
            AppendColored("Circular reference detected: ", defaultColor);
            AppendColored(wxString::FromUTF8(ref.c_str()) + "\n", errorColor);
        }
        AppendColored("\n", defaultColor);
    }
 
    // Tree reference map
    AppendColored("TREE REFERENCE MAP:\n", headerColor);
    for (const auto &pair : report.tree_statuses) {
        const auto &id = pair.first;
        const auto &status = pair.second;
        if (status.is_implemented) {
            AppendColored("  [OK] ", successColor);
            AppendColored(wxString::FromUTF8(id.c_str()), defaultColor);
            AppendColored(" (implemented in ", infoColor);
            AppendColored(wxString::FromUTF8(status.defined_in_file.c_str()), infoColor);
            AppendColored(")\n", infoColor);
        } else {
            AppendColored("  [!!] ", warningColor);
            AppendColored(wxString::FromUTF8(id.c_str()), warningColor);
            AppendColored(" (not implemented)\n", defaultColor);
        }
        for (const auto &ref_file : status.referenced_in_files) {
            AppendColored("    <- referenced by ", infoColor);
            AppendColored(wxString::FromUTF8(ref_file.c_str()) + "\n", defaultColor);
        }
    }
}
 
void BehaviorTreeProjectDialog::UpdateTreePreview() {
    // Reset selection when updating preview
    m_selectedItemIndex = -1;
 
    if (!m_lastValidationReport) {
        m_treeCountLabel->SetLabel("No validation data - click Validate first");
        m_fileStructurePanel->Refresh();
        return;
    }
 
    // Count implemented trees
    int implementedTrees = 0;
    for (const auto &pair : m_lastValidationReport->tree_statuses) {
        if (pair.second.is_implemented) {
            implementedTrees++;
        }
    }
 
    // Count blackboards
    int totalBlackboards = 0;
    for (const auto &rs : m_lastValidationReport->resource_statuses) {
        totalBlackboards += rs.blackboard_count;
    }
 
    // Update count label
    m_treeCountLabel->SetLabel(wxString::Format("%d tree(s), %d blackboard(s), %zu unimplemented ref(s)",
                                                implementedTrees, totalBlackboards,
                                                m_lastValidationReport->unimplemented_trees.size()));
 
    // Trigger repaint
    m_fileStructurePanel->Refresh();
}
 
void BehaviorTreeProjectDialog::DrawFileStructureDiagram(wxDC &dc) {
    // Clear background
    dc.SetBackground(wxBrush(wxColour(45, 45, 45)));
    dc.Clear();
 
    // Clear clickable items
    m_clickableItems.clear();
 
    if (!m_lastValidationReport) {
        // Draw "No data" message
        dc.SetTextForeground(wxColour(150, 150, 150));
        wxFont font(12, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
        dc.SetFont(font);
        dc.DrawText("Click 'Validate' to see structure", 20, 20);
        return;
    }
 
    // Group trees by file
    std::map<std::string, std::vector<std::string>> treesByFile;
    for (const auto &pair : m_lastValidationReport->tree_statuses) {
        const auto &status = pair.second;
        if (status.is_implemented) {
            treesByFile[status.defined_in_file].push_back(status.tree_id);
        }
    }
 
    // Ensure blackboard-only files also appear in the treesByFile map
    // (with an empty tree list) so they get drawn in the main loop
    for (const auto &rs : m_lastValidationReport->resource_statuses) {
        if (rs.has_blackboards && treesByFile.find(rs.filepath) == treesByFile.end()) {
            treesByFile[rs.filepath] = {}; // Empty tree list, but file will be drawn
        }
    }
 
    // Drawing parameters
    int fileBoxWidth = 250;
    int fileBoxHeight = 40;
    int treeBoxWidth = 200;
    int treeBoxHeight = 35;
    int spacing = 20;
    int leftMargin = 30;
    int topMargin = 30;
 
    wxFont titleFont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD);
    wxFont normalFont(9, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
 
    int currentY = topMargin;
 
    // Get filter states
    bool showProjectIssues = !m_showProjectIssuesCheckBox || m_showProjectIssuesCheckBox->GetValue();
    bool showFiles = !m_showFilesCheckBox || m_showFilesCheckBox->GetValue();
    bool showTrees = !m_showTreesCheckBox || m_showTreesCheckBox->GetValue();
    bool showBlackboards = !m_showBlackboardsCheckBox || m_showBlackboardsCheckBox->GetValue();
    bool showErrors = !m_showErrorsCheckBox || m_showErrorsCheckBox->GetValue();
    bool showWarnings = !m_showWarningsCheckBox || m_showWarningsCheckBox->GetValue();
 
    // Build map of which files reference which unimplemented trees
    std::map<std::string, std::vector<std::string>> fileToUnimplementedRefs;
    for (const auto &unimp : m_lastValidationReport->unimplemented_trees) {
        // Find which files reference this tree
        for (const auto &resource : m_lastValidationReport->resource_statuses) {
            for (const auto &ref : resource.subtree_refs) {
                if (ref == unimp) {
                    fileToUnimplementedRefs[resource.filepath].push_back(unimp);
                    break;
                }
            }
        }
    }
 
    // Section 1: Draw project-level ERRORS (critical issues)
    if (showProjectIssues && !m_lastValidationReport->errors.empty()) {
        dc.SetFont(titleFont);
        dc.SetTextForeground(wxColour(255, 100, 100));
        dc.DrawText("❌ Project Errors:", leftMargin, currentY);
        currentY += 30;
 
        for (const auto &error : m_lastValidationReport->errors) {
            int errorX = leftMargin + 20;
 
            // Draw error box
            dc.SetBrush(wxBrush(wxColour(80, 40, 40)));
            dc.SetPen(wxPen(wxColour(255, 100, 100), 2));
            dc.DrawRoundedRectangle(errorX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
            // Draw error icon (X)
            dc.SetBrush(wxBrush(wxColour(255, 100, 100)));
            dc.SetPen(wxPen(wxColour(200, 80, 80), 2));
            dc.DrawLine(errorX + 10, currentY + 10, errorX + 20, currentY + 20);
            dc.DrawLine(errorX + 20, currentY + 10, errorX + 10, currentY + 20);
 
            // Draw error text (truncate if needed)
            dc.SetFont(normalFont);
            dc.SetTextForeground(wxColour(255, 150, 150));
            wxString errorText = wxString::FromUTF8(error);
            int maxTextWidth = treeBoxWidth - 40;
            wxSize textExtent = dc.GetTextExtent(errorText);
            if (textExtent.GetWidth() > maxTextWidth) {
                while (!errorText.IsEmpty() && dc.GetTextExtent(errorText + "...").GetWidth() > maxTextWidth) {
                    errorText = errorText.Left(errorText.Length() - 1);
                }
                errorText += "...";
            }
            dc.DrawText(errorText, errorX + 30, currentY + 10);
 
            // Track as clickable item
            ClickableItem item;
            item.type = ClickableItem::Warning; // Reuse warning type for now
            item.rect = wxRect(errorX, currentY, treeBoxWidth, treeBoxHeight);
            item.identifier = error;
            item.filepath = "";
            item.line_number = -1;
 
            int itemIndex = m_clickableItems.size();
            m_clickableItems.push_back(item);
 
            if (itemIndex == m_selectedItemIndex) {
                dc.SetBrush(*wxTRANSPARENT_BRUSH);
                dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                dc.DrawRoundedRectangle(errorX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
            }
 
            currentY += treeBoxHeight + 10;
        }
        currentY += spacing;
    }
 
    // Section 2: Draw circular dependencies
    if (showProjectIssues && !m_lastValidationReport->circular_references.empty()) {
        dc.SetFont(titleFont);
        dc.SetTextForeground(wxColour(255, 150, 100));
        dc.DrawText("🔄 Circular Dependencies:", leftMargin, currentY);
        currentY += 30;
 
        for (const auto &circular : m_lastValidationReport->circular_references) {
            int circX = leftMargin + 20;
 
            // Draw warning box
            dc.SetBrush(wxBrush(wxColour(80, 50, 40)));
            dc.SetPen(wxPen(wxColour(255, 150, 100), 2));
            dc.DrawRoundedRectangle(circX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
            // Draw circular icon
            dc.SetBrush(*wxTRANSPARENT_BRUSH);
            dc.SetPen(wxPen(wxColour(255, 150, 100), 2));
            dc.DrawCircle(circX + 15, currentY + 17, 8);
            dc.SetBrush(wxBrush(wxColour(255, 150, 100)));
            wxPoint circArrow[3] = {wxPoint(circX + 23, currentY + 14), wxPoint(circX + 23, currentY + 20),
                                    wxPoint(circX + 27, currentY + 17)};
            dc.DrawPolygon(3, circArrow);
 
            // Draw circular ref text
            dc.SetFont(normalFont);
            dc.SetTextForeground(wxColour(255, 180, 120));
            wxString circText = wxString::FromUTF8(circular);
            int maxTextWidth = treeBoxWidth - 40;
            wxSize textExtent = dc.GetTextExtent(circText);
            if (textExtent.GetWidth() > maxTextWidth) {
                while (!circText.IsEmpty() && dc.GetTextExtent(circText + "...").GetWidth() > maxTextWidth) {
                    circText = circText.Left(circText.Length() - 1);
                }
                circText += "...";
            }
            dc.DrawText(circText, circX + 30, currentY + 10);
 
            // Track as clickable
            ClickableItem item;
            item.type = ClickableItem::Warning;
            item.rect = wxRect(circX, currentY, treeBoxWidth, treeBoxHeight);
            item.identifier = circular;
            item.filepath = "";
            item.line_number = -1;
 
            int itemIndex = m_clickableItems.size();
            m_clickableItems.push_back(item);
 
            if (itemIndex == m_selectedItemIndex) {
                dc.SetBrush(*wxTRANSPARENT_BRUSH);
                dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                dc.DrawRoundedRectangle(circX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
            }
 
            currentY += treeBoxHeight + 10;
        }
        currentY += spacing;
    }
 
    // Section 3: Draw unimplemented references (NOW SHOWN UNDER EACH FILE INSTEAD)
    // Disabled - unimplemented refs are now shown as warnings under their corresponding files
    if (false && !m_lastValidationReport->unimplemented_trees.empty()) {
        // Draw section header
        dc.SetFont(titleFont);
        dc.SetTextForeground(wxColour(255, 200, 100));
        dc.DrawText("Unimplemented References:", leftMargin, currentY);
        currentY += 30;
 
        // Draw each unimplemented reference
        for (const auto &treeId : m_lastValidationReport->unimplemented_trees) {
            int treeX = leftMargin + 20;
 
            // Draw warning box
            dc.SetBrush(wxBrush(wxColour(80, 60, 40)));
            dc.SetPen(wxPen(wxColour(255, 180, 0), 2));
            dc.DrawRoundedRectangle(treeX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
            // Draw warning icon (triangle with !)
            dc.SetBrush(wxBrush(wxColour(255, 180, 0)));
            dc.SetPen(wxPen(wxColour(200, 140, 0), 1));
            wxPoint warnIcon[3] = {wxPoint(treeX + 15, currentY + 10), wxPoint(treeX + 10, currentY + 25),
                                   wxPoint(treeX + 20, currentY + 25)};
            dc.DrawPolygon(3, warnIcon);
            dc.SetTextForeground(wxColour(50, 30, 0));
            dc.DrawText("!", treeX + 13, currentY + 11);
 
            // Draw tree ID (truncate if too long)
            dc.SetFont(normalFont);
            dc.SetTextForeground(wxColour(255, 200, 100));
            wxString treeIdText = wxString::FromUTF8(treeId);
 
            // Measure text and truncate if necessary to fit in box
            int maxTextWidth = treeBoxWidth - 40; // Account for icon space and margins
            wxSize textExtent = dc.GetTextExtent(treeIdText);
            if (textExtent.GetWidth() > maxTextWidth) {
                // Truncate with ellipsis
                while (!treeIdText.IsEmpty() && dc.GetTextExtent(treeIdText + "...").GetWidth() > maxTextWidth) {
                    treeIdText = treeIdText.Left(treeIdText.Length() - 1);
                }
                treeIdText += "...";
            }
 
            dc.DrawText(treeIdText, treeX + 30, currentY + 10);
 
            // Find which file references this tree
            std::string referenceFile;
            for (const auto &resource : m_lastValidationReport->resource_statuses) {
                for (const auto &ref : resource.subtree_refs) {
                    if (ref == treeId) {
                        referenceFile = resource.filepath;
                        break;
                    }
                }
                if (!referenceFile.empty())
                    break;
            }
 
            // Track as clickable item
            ClickableItem item;
            item.type = ClickableItem::Warning;
            item.rect = wxRect(treeX, currentY, treeBoxWidth, treeBoxHeight);
            item.identifier = treeId;
            item.filepath = referenceFile;
            item.line_number = -1; // We'll search for it when clicked
 
            int itemIndex = m_clickableItems.size();
            m_clickableItems.push_back(item);
 
            // Draw selection highlight if this item is selected
            if (itemIndex == m_selectedItemIndex) {
                dc.SetBrush(*wxTRANSPARENT_BRUSH);
                dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker  // Bright blue border
                dc.DrawRoundedRectangle(treeX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
            }
 
            currentY += treeBoxHeight + 10;
        }
 
        currentY += spacing * 2; // Extra spacing after warnings
    }
 
    // Section 4: Draw files with errors but no trees
    std::set<std::string> filesWithTreesOrErrors;
 
    // First, check if there are any files with errors/warnings/unimplemented refs that don't have trees
    bool hasFilesWithIssuesButNoTrees = false;
    if (showFiles || showErrors || showWarnings) {
        for (const auto &resource : m_lastValidationReport->resource_statuses) {
            bool hasIssues = (!resource.errors.empty() && showErrors) || (!resource.warnings.empty() && showWarnings) ||
                             (!fileToUnimplementedRefs[resource.filepath].empty() && showWarnings);
            if (hasIssues && treesByFile.find(resource.filepath) == treesByFile.end()) {
                hasFilesWithIssuesButNoTrees = true;
                break;
            }
        }
    }
 
    // Draw section header if there are files with issues
    if (hasFilesWithIssuesButNoTrees) {
        dc.SetFont(titleFont);
        dc.SetTextForeground(wxColour(255, 150, 100));
        dc.DrawText("Files with Issues:", leftMargin, currentY);
        currentY += 30;
    }
 
    for (const auto &resource : m_lastValidationReport->resource_statuses) {
        // Check if this file has any items that should be shown based on filters
        bool hasVisibleErrors = showErrors && !resource.errors.empty();
        bool hasVisibleWarnings =
            showWarnings && (!resource.warnings.empty() || !fileToUnimplementedRefs[resource.filepath].empty());
 
        if (hasVisibleErrors || hasVisibleWarnings) {
            // Check if this file is NOT in treesByFile (no valid trees)
            if (treesByFile.find(resource.filepath) == treesByFile.end()) {
                filesWithTreesOrErrors.insert(resource.filepath);
 
                wxFileName fn(wxString::FromUTF8(resource.filepath));
                wxSize textExtent; // Declare here for use throughout this section
 
                // Only draw file box if showFiles is true
                if (showFiles) {
                    // Draw file box
                    dc.SetBrush(wxBrush(wxColour(70, 70, 90)));
                    dc.SetPen(wxPen(wxColour(100, 100, 150), 2));
                    dc.DrawRoundedRectangle(leftMargin, currentY, fileBoxWidth, fileBoxHeight, 5);
 
                    // Draw file icon
                    dc.SetBrush(wxBrush(wxColour(100, 150, 255)));
                    dc.SetPen(wxPen(wxColour(80, 120, 200), 1));
                    dc.DrawRectangle(leftMargin + 10, currentY + 10, 20, 20);
 
                    // Draw file name (truncate if too long)
                    dc.SetFont(titleFont);
                    dc.SetTextForeground(wxColour(200, 200, 255));
                    wxString fileName = fn.GetFullName();
                    int maxFileTextWidth = fileBoxWidth - 50;
                    textExtent = dc.GetTextExtent(fileName);
                    if (textExtent.GetWidth() > maxFileTextWidth) {
                        while (!fileName.IsEmpty() &&
                               dc.GetTextExtent(fileName + "...").GetWidth() > maxFileTextWidth) {
                            fileName = fileName.Left(fileName.Length() - 1);
                        }
                        fileName += "...";
                    }
                    dc.DrawText(fileName, leftMargin + 40, currentY + 12);
 
                    // Track file as clickable
                    ClickableItem fileItem;
                    fileItem.type = ClickableItem::File;
                    fileItem.rect = wxRect(leftMargin, currentY, fileBoxWidth, fileBoxHeight);
                    fileItem.identifier = resource.filepath;
                    fileItem.filepath = resource.filepath;
                    fileItem.line_number = -1;
 
                    int fileItemIndex = m_clickableItems.size();
                    m_clickableItems.push_back(fileItem);
 
                    if (fileItemIndex == m_selectedItemIndex) {
                        dc.SetBrush(*wxTRANSPARENT_BRUSH);
                        dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                        dc.DrawRoundedRectangle(leftMargin - 2, currentY - 2, fileBoxWidth + 4, fileBoxHeight + 4, 5);
                    }
 
                    currentY += fileBoxHeight + spacing;
                }
 
                // Draw errors for this file
                if (showErrors) {
                    for (const auto &error : resource.errors) {
                        int errorX = leftMargin + 40;
 
                        dc.SetBrush(wxBrush(wxColour(80, 40, 40)));
                        dc.SetPen(wxPen(wxColour(255, 100, 100), 2));
                        dc.DrawRoundedRectangle(errorX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                        dc.SetBrush(wxBrush(wxColour(255, 100, 100)));
                        dc.SetPen(wxPen(wxColour(200, 80, 80), 2));
                        dc.DrawLine(errorX + 10, currentY + 10, errorX + 20, currentY + 20);
                        dc.DrawLine(errorX + 20, currentY + 10, errorX + 10, currentY + 20);
 
                        dc.SetFont(normalFont);
                        dc.SetTextForeground(wxColour(255, 150, 150));
                        wxString errorText = wxString::FromUTF8(error);
                        int maxTextWidth = treeBoxWidth - 40;
                        textExtent = dc.GetTextExtent(errorText);
                        if (textExtent.GetWidth() > maxTextWidth) {
                            while (!errorText.IsEmpty() &&
                                   dc.GetTextExtent(errorText + "...").GetWidth() > maxTextWidth) {
                                errorText = errorText.Left(errorText.Length() - 1);
                            }
                            errorText += "...";
                        }
                        dc.DrawText(errorText, errorX + 30, currentY + 10);
 
                        ClickableItem errorItem;
                        errorItem.type = ClickableItem::Warning;
                        errorItem.rect = wxRect(errorX, currentY, treeBoxWidth, treeBoxHeight);
                        errorItem.identifier = error;
                        errorItem.filepath = resource.filepath;
                        errorItem.line_number = -1;
 
                        int errorItemIndex = m_clickableItems.size();
                        m_clickableItems.push_back(errorItem);
 
                        if (errorItemIndex == m_selectedItemIndex) {
                            dc.SetBrush(*wxTRANSPARENT_BRUSH);
                            dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                            dc.DrawRoundedRectangle(errorX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                        }
 
                        currentY += treeBoxHeight + 10;
                    }
                }
 
                // Draw warnings for this file
                if (showWarnings) {
                    for (const auto &warning : resource.warnings) {
                        int warnX = leftMargin + 40;
 
                        dc.SetBrush(wxBrush(wxColour(80, 60, 40)));
                        dc.SetPen(wxPen(wxColour(255, 180, 0), 2));
                        dc.DrawRoundedRectangle(warnX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                        dc.SetBrush(wxBrush(wxColour(255, 180, 0)));
                        dc.SetPen(wxPen(wxColour(200, 140, 0), 1));
                        wxPoint warnIcon[3] = {wxPoint(warnX + 15, currentY + 10), wxPoint(warnX + 10, currentY + 25),
                                               wxPoint(warnX + 20, currentY + 25)};
                        dc.DrawPolygon(3, warnIcon);
                        dc.SetTextForeground(wxColour(50, 30, 0));
                        dc.DrawText("!", warnX + 13, currentY + 11);
 
                        dc.SetFont(normalFont);
                        dc.SetTextForeground(wxColour(255, 200, 100));
                        wxString warnText = wxString::FromUTF8(warning);
                        int maxTextWidth = treeBoxWidth - 40;
                        textExtent = dc.GetTextExtent(warnText);
                        if (textExtent.GetWidth() > maxTextWidth) {
                            while (!warnText.IsEmpty() &&
                                   dc.GetTextExtent(warnText + "...").GetWidth() > maxTextWidth) {
                                warnText = warnText.Left(warnText.Length() - 1);
                            }
                            warnText += "...";
                        }
                        dc.DrawText(warnText, warnX + 30, currentY + 10);
 
                        ClickableItem warnItem;
                        warnItem.type = ClickableItem::Warning;
                        warnItem.rect = wxRect(warnX, currentY, treeBoxWidth, treeBoxHeight);
                        warnItem.identifier = warning;
                        warnItem.filepath = resource.filepath;
                        warnItem.line_number = -1;
 
                        int warnItemIndex = m_clickableItems.size();
                        m_clickableItems.push_back(warnItem);
 
                        if (warnItemIndex == m_selectedItemIndex) {
                            dc.SetBrush(*wxTRANSPARENT_BRUSH);
                            dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                            dc.DrawRoundedRectangle(warnX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                        }
 
                        currentY += treeBoxHeight + 10;
                    }
                }
 
                // Draw unimplemented references for this file
                if (showWarnings && fileToUnimplementedRefs.count(resource.filepath) > 0) {
                    for (const auto &unimpRef : fileToUnimplementedRefs[resource.filepath]) {
                        int warnX = leftMargin + 40;
 
                        dc.SetBrush(wxBrush(wxColour(80, 60, 40)));
                        dc.SetPen(wxPen(wxColour(255, 180, 0), 2));
                        dc.DrawRoundedRectangle(warnX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                        dc.SetBrush(wxBrush(wxColour(255, 180, 0)));
                        dc.SetPen(wxPen(wxColour(200, 140, 0), 1));
                        wxPoint warnIcon[3] = {wxPoint(warnX + 15, currentY + 10), wxPoint(warnX + 10, currentY + 25),
                                               wxPoint(warnX + 20, currentY + 25)};
                        dc.DrawPolygon(3, warnIcon);
                        dc.SetTextForeground(wxColour(50, 30, 0));
                        dc.DrawText("!", warnX + 13, currentY + 11);
 
                        dc.SetFont(normalFont);
                        dc.SetTextForeground(wxColour(255, 200, 100));
                        wxString warnText = "Missing reference: " + wxString::FromUTF8(unimpRef);
                        int maxTextWidth = treeBoxWidth - 40;
                        textExtent = dc.GetTextExtent(warnText);
                        if (textExtent.GetWidth() > maxTextWidth) {
                            while (!warnText.IsEmpty() &&
                                   dc.GetTextExtent(warnText + "...").GetWidth() > maxTextWidth) {
                                warnText = warnText.Left(warnText.Length() - 1);
                            }
                            warnText += "...";
                        }
                        dc.DrawText(warnText, warnX + 30, currentY + 10);
 
                        ClickableItem warnItem;
                        warnItem.type = ClickableItem::Warning;
                        warnItem.rect = wxRect(warnX, currentY, treeBoxWidth, treeBoxHeight);
                        warnItem.identifier = unimpRef;
                        warnItem.filepath = resource.filepath;
                        warnItem.line_number = -1;
 
                        int warnItemIndex = m_clickableItems.size();
                        m_clickableItems.push_back(warnItem);
 
                        if (warnItemIndex == m_selectedItemIndex) {
                            dc.SetBrush(*wxTRANSPARENT_BRUSH);
                            dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                            dc.DrawRoundedRectangle(warnX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                        }
 
                        currentY += treeBoxHeight + 10;
                    }
                }
 
                currentY += spacing;
            }
        }
    }
 
    // Draw section header for implemented trees
    if ((showFiles || showTrees) && !treesByFile.empty()) {
        dc.SetFont(titleFont);
        dc.SetTextForeground(wxColour(150, 200, 255));
        dc.DrawText("Implemented Trees:", leftMargin, currentY);
        currentY += 30;
    }
 
    // Draw each file and its trees
    for (const auto &pair : treesByFile) {
        // Check if this file has anything visible based on filters
        const EmberCore::ResourceValidationStatus *resourceStatus = nullptr;
        for (const auto &resource : m_lastValidationReport->resource_statuses) {
            if (resource.filepath == pair.first) {
                resourceStatus = &resource;
                break;
            }
        }
 
        bool hasVisibleErrors = showErrors && resourceStatus && !resourceStatus->errors.empty();
        bool hasVisibleWarnings = showWarnings && resourceStatus &&
                                  (!resourceStatus->warnings.empty() || !fileToUnimplementedRefs[pair.first].empty());
        bool hasVisibleTrees = showTrees && !pair.second.empty();
        bool hasVisibleBlackboards = showBlackboards && resourceStatus && !resourceStatus->blackboard_ids.empty();
 
        // Skip this file entirely if nothing should be visible
        if (!showFiles && !hasVisibleErrors && !hasVisibleWarnings && !hasVisibleTrees && !hasVisibleBlackboards) {
            continue;
        }
        wxFileName fn(wxString::FromUTF8(pair.first));
        wxSize textExtent; // Declare here for use throughout this file's section
 
        // Only draw file box if showFiles is true
        if (showFiles) {
            // Draw file box
            dc.SetBrush(wxBrush(wxColour(70, 70, 90)));
            dc.SetPen(wxPen(wxColour(100, 100, 150), 2));
            dc.DrawRoundedRectangle(leftMargin, currentY, fileBoxWidth, fileBoxHeight, 5);
 
            // Draw file icon
            dc.SetBrush(wxBrush(wxColour(100, 150, 255)));
            dc.SetPen(wxPen(wxColour(80, 120, 200), 1));
            dc.DrawRectangle(leftMargin + 10, currentY + 10, 20, 20);
 
            // Draw file name (truncate if too long)
            dc.SetFont(titleFont);
            dc.SetTextForeground(wxColour(200, 200, 255));
            wxString fileName = fn.GetFullName();
 
            // Measure text and truncate if necessary to fit in box
            int maxFileTextWidth = fileBoxWidth - 50; // Account for icon space and margins
            textExtent = dc.GetTextExtent(fileName);
            if (textExtent.GetWidth() > maxFileTextWidth) {
                // Truncate with ellipsis
                while (!fileName.IsEmpty() && dc.GetTextExtent(fileName + "...").GetWidth() > maxFileTextWidth) {
                    fileName = fileName.Left(fileName.Length() - 1);
                }
                fileName += "...";
            }
 
            dc.DrawText(fileName, leftMargin + 40, currentY + 12);
 
            // Track file as clickable
            ClickableItem fileItem;
            fileItem.type = ClickableItem::File;
            fileItem.rect = wxRect(leftMargin, currentY, fileBoxWidth, fileBoxHeight);
            fileItem.identifier = pair.first;
            fileItem.filepath = pair.first;
            fileItem.line_number = -1;
 
            int fileItemIndex = m_clickableItems.size();
            m_clickableItems.push_back(fileItem);
 
            // Draw selection highlight if this item is selected
            if (fileItemIndex == m_selectedItemIndex) {
                dc.SetBrush(*wxTRANSPARENT_BRUSH);
                dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker  // Bright blue border
                dc.DrawRoundedRectangle(leftMargin - 2, currentY - 2, fileBoxWidth + 4, fileBoxHeight + 4, 5);
            }
 
            currentY += fileBoxHeight + spacing;
        }
 
        // Draw file-level errors (if any)
        if (showErrors && resourceStatus && !resourceStatus->errors.empty()) {
            for (const auto &error : resourceStatus->errors) {
                int errorX = leftMargin + 40;
 
                // Draw error box
                dc.SetBrush(wxBrush(wxColour(80, 40, 40)));
                dc.SetPen(wxPen(wxColour(255, 100, 100), 2));
                dc.DrawRoundedRectangle(errorX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                // Draw error icon (X)
                dc.SetBrush(wxBrush(wxColour(255, 100, 100)));
                dc.SetPen(wxPen(wxColour(200, 80, 80), 2));
                dc.DrawLine(errorX + 10, currentY + 10, errorX + 20, currentY + 20);
                dc.DrawLine(errorX + 20, currentY + 10, errorX + 10, currentY + 20);
 
                // Draw error text
                dc.SetFont(normalFont);
                dc.SetTextForeground(wxColour(255, 150, 150));
                wxString errorText = wxString::FromUTF8(error);
                int maxTextWidth = treeBoxWidth - 40;
                wxSize textExtent = dc.GetTextExtent(errorText);
                if (textExtent.GetWidth() > maxTextWidth) {
                    while (!errorText.IsEmpty() && dc.GetTextExtent(errorText + "...").GetWidth() > maxTextWidth) {
                        errorText = errorText.Left(errorText.Length() - 1);
                    }
                    errorText += "...";
                }
                dc.DrawText(errorText, errorX + 30, currentY + 10);
 
                // Track as clickable
                ClickableItem errorItem;
                errorItem.type = ClickableItem::Warning;
                errorItem.rect = wxRect(errorX, currentY, treeBoxWidth, treeBoxHeight);
                errorItem.identifier = error;
                errorItem.filepath = pair.first;
                errorItem.line_number = -1;
 
                int errorItemIndex = m_clickableItems.size();
                m_clickableItems.push_back(errorItem);
 
                if (errorItemIndex == m_selectedItemIndex) {
                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
                    dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                    dc.DrawRoundedRectangle(errorX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                }
 
                currentY += treeBoxHeight + 10;
            }
        }
 
        // Draw file-level warnings (if any)
        if (showWarnings && resourceStatus && !resourceStatus->warnings.empty()) {
            for (const auto &warning : resourceStatus->warnings) {
                int warnX = leftMargin + 40;
 
                // Draw warning box
                dc.SetBrush(wxBrush(wxColour(80, 60, 40)));
                dc.SetPen(wxPen(wxColour(255, 180, 0), 2));
                dc.DrawRoundedRectangle(warnX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                // Draw warning icon (triangle with !)
                dc.SetBrush(wxBrush(wxColour(255, 180, 0)));
                dc.SetPen(wxPen(wxColour(200, 140, 0), 1));
                wxPoint warnIcon[3] = {wxPoint(warnX + 15, currentY + 10), wxPoint(warnX + 10, currentY + 25),
                                       wxPoint(warnX + 20, currentY + 25)};
                dc.DrawPolygon(3, warnIcon);
                dc.SetTextForeground(wxColour(50, 30, 0));
                dc.DrawText("!", warnX + 13, currentY + 11);
 
                // Draw warning text
                dc.SetFont(normalFont);
                dc.SetTextForeground(wxColour(255, 200, 100));
                wxString warnText = wxString::FromUTF8(warning);
                int maxTextWidth = treeBoxWidth - 40;
                wxSize textExtent = dc.GetTextExtent(warnText);
                if (textExtent.GetWidth() > maxTextWidth) {
                    while (!warnText.IsEmpty() && dc.GetTextExtent(warnText + "...").GetWidth() > maxTextWidth) {
                        warnText = warnText.Left(warnText.Length() - 1);
                    }
                    warnText += "...";
                }
                dc.DrawText(warnText, warnX + 30, currentY + 10);
 
                // Track as clickable
                ClickableItem warnItem;
                warnItem.type = ClickableItem::Warning;
                warnItem.rect = wxRect(warnX, currentY, treeBoxWidth, treeBoxHeight);
                warnItem.identifier = warning;
                warnItem.filepath = pair.first;
                warnItem.line_number = -1;
 
                int warnItemIndex = m_clickableItems.size();
                m_clickableItems.push_back(warnItem);
 
                if (warnItemIndex == m_selectedItemIndex) {
                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
                    dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                    dc.DrawRoundedRectangle(warnX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                }
 
                currentY += treeBoxHeight + 10;
            }
        }
 
        // Draw unimplemented references for this file
        if (showWarnings && fileToUnimplementedRefs.count(pair.first) > 0) {
            for (const auto &unimpRef : fileToUnimplementedRefs[pair.first]) {
                int warnX = leftMargin + 40;
 
                dc.SetBrush(wxBrush(wxColour(80, 60, 40)));
                dc.SetPen(wxPen(wxColour(255, 180, 0), 2));
                dc.DrawRoundedRectangle(warnX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                dc.SetBrush(wxBrush(wxColour(255, 180, 0)));
                dc.SetPen(wxPen(wxColour(200, 140, 0), 1));
                wxPoint warnIcon[3] = {wxPoint(warnX + 15, currentY + 10), wxPoint(warnX + 10, currentY + 25),
                                       wxPoint(warnX + 20, currentY + 25)};
                dc.DrawPolygon(3, warnIcon);
                dc.SetTextForeground(wxColour(50, 30, 0));
                dc.DrawText("!", warnX + 13, currentY + 11);
 
                dc.SetFont(normalFont);
                dc.SetTextForeground(wxColour(255, 200, 100));
                wxString warnText = "Missing reference: " + wxString::FromUTF8(unimpRef);
                int maxTextWidth = treeBoxWidth - 40;
                wxSize textExtent = dc.GetTextExtent(warnText);
                if (textExtent.GetWidth() > maxTextWidth) {
                    while (!warnText.IsEmpty() && dc.GetTextExtent(warnText + "...").GetWidth() > maxTextWidth) {
                        warnText = warnText.Left(warnText.Length() - 1);
                    }
                    warnText += "...";
                }
                dc.DrawText(warnText, warnX + 30, currentY + 10);
 
                ClickableItem warnItem;
                warnItem.type = ClickableItem::Warning;
                warnItem.rect = wxRect(warnX, currentY, treeBoxWidth, treeBoxHeight);
                warnItem.identifier = unimpRef;
                warnItem.filepath = pair.first;
                warnItem.line_number = -1;
 
                int warnItemIndex = m_clickableItems.size();
                m_clickableItems.push_back(warnItem);
 
                if (warnItemIndex == m_selectedItemIndex) {
                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
                    dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker
                    dc.DrawRoundedRectangle(warnX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                }
 
                currentY += treeBoxHeight + 10;
            }
        }
 
        // Draw trees in this file
        if (showTrees) {
            for (const auto &treeId : pair.second) {
                // Indent trees under their file
                int treeX = leftMargin + 40;
 
                // Draw tree box
                dc.SetBrush(wxBrush(wxColour(60, 80, 60)));
                dc.SetPen(wxPen(wxColour(100, 180, 100), 2));
                dc.DrawRoundedRectangle(treeX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                // Draw tree icon (simple triangle)
                dc.SetBrush(wxBrush(wxColour(80, 200, 100)));
                dc.SetPen(wxPen(wxColour(60, 160, 80), 1));
                wxPoint treeIcon[3] = {wxPoint(treeX + 15, currentY + 10), wxPoint(treeX + 10, currentY + 25),
                                       wxPoint(treeX + 20, currentY + 25)};
                dc.DrawPolygon(3, treeIcon);
 
                // Draw tree ID (truncate if too long)
                dc.SetFont(normalFont);
                dc.SetTextForeground(wxColour(150, 255, 150));
                wxString treeIdText = wxString::FromUTF8(treeId);
 
                // Measure text and truncate if necessary to fit in box
                int maxTextWidth = treeBoxWidth - 40; // Account for icon space and margins
                wxSize textExtent = dc.GetTextExtent(treeIdText);
                if (textExtent.GetWidth() > maxTextWidth) {
                    // Truncate with ellipsis
                    while (!treeIdText.IsEmpty() && dc.GetTextExtent(treeIdText + "...").GetWidth() > maxTextWidth) {
                        treeIdText = treeIdText.Left(treeIdText.Length() - 1);
                    }
                    treeIdText += "...";
                }
 
                dc.DrawText(treeIdText, treeX + 30, currentY + 10);
 
                // Track tree as clickable
                ClickableItem treeItem;
                treeItem.type = ClickableItem::Tree;
                treeItem.rect = wxRect(treeX, currentY, treeBoxWidth, treeBoxHeight);
                treeItem.identifier = treeId;
                treeItem.filepath = pair.first;
                treeItem.line_number = -1;
 
                int treeItemIndex = m_clickableItems.size();
                m_clickableItems.push_back(treeItem);
 
                // Draw selection highlight if this item is selected
                if (treeItemIndex == m_selectedItemIndex) {
                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
                    dc.SetPen(wxPen(wxColour(0, 255, 255), 4)); // Bright cyan, thicker  // Bright blue border
                    dc.DrawRoundedRectangle(treeX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                }
 
                currentY += treeBoxHeight + 10;
            }
        }
 
        // Draw blackboards in this file
        if (showBlackboards && resourceStatus && !resourceStatus->blackboard_ids.empty()) {
            for (const auto &bbId : resourceStatus->blackboard_ids) {
                int bbX = leftMargin + 40;
 
                // Draw blackboard box (purple/magenta theme)
                dc.SetBrush(wxBrush(wxColour(70, 50, 80)));
                dc.SetPen(wxPen(wxColour(160, 100, 200), 2));
                dc.DrawRoundedRectangle(bbX, currentY, treeBoxWidth, treeBoxHeight, 5);
 
                // Draw blackboard icon (small grid)
                dc.SetBrush(wxBrush(wxColour(180, 120, 230)));
                dc.SetPen(wxPen(wxColour(140, 90, 190), 1));
                dc.DrawRectangle(bbX + 10, currentY + 10, 16, 16);
                dc.DrawLine(bbX + 10, currentY + 18, bbX + 26, currentY + 18);
                dc.DrawLine(bbX + 18, currentY + 10, bbX + 18, currentY + 26);
 
                // Draw blackboard ID (truncate if too long)
                dc.SetFont(normalFont);
                dc.SetTextForeground(wxColour(200, 160, 255));
                wxString bbText = wxString::FromUTF8(bbId);
 
                int maxTextWidth = treeBoxWidth - 40;
                wxSize bbTextExtent = dc.GetTextExtent(bbText);
                if (bbTextExtent.GetWidth() > maxTextWidth) {
                    while (!bbText.IsEmpty() && dc.GetTextExtent(bbText + "...").GetWidth() > maxTextWidth) {
                        bbText = bbText.Left(bbText.Length() - 1);
                    }
                    bbText += "...";
                }
 
                dc.DrawText(bbText, bbX + 30, currentY + 10);
 
                // Track blackboard as clickable
                ClickableItem bbItem;
                bbItem.type = ClickableItem::Blackboard;
                bbItem.rect = wxRect(bbX, currentY, treeBoxWidth, treeBoxHeight);
                bbItem.identifier = bbId;
                bbItem.filepath = pair.first;
                bbItem.line_number = -1;
 
                int bbItemIndex = m_clickableItems.size();
                m_clickableItems.push_back(bbItem);
 
                // Draw selection highlight if this item is selected
                if (bbItemIndex == m_selectedItemIndex) {
                    dc.SetBrush(*wxTRANSPARENT_BRUSH);
                    dc.SetPen(wxPen(wxColour(0, 255, 255), 4));
                    dc.DrawRoundedRectangle(bbX - 2, currentY - 2, treeBoxWidth + 4, treeBoxHeight + 4, 5);
                }
 
                currentY += treeBoxHeight + 10;
            }
        }
 
        currentY += spacing;
    }
 
    // Set virtual size for scrolling
    m_fileStructurePanel->SetVirtualSize(fileBoxWidth + leftMargin + 50, currentY + 20);
}
 
void BehaviorTreeProjectDialog::UpdateCreateButtonState() {
    wxString name = m_projectName->GetValue().Trim();
    bool canCreate = !name.IsEmpty() && IsValidProjectName(name) && m_project->GetResourceCount() > 0;
 
    // For create mode, we allow creating even if validation fails
    // The user will see warnings but can still proceed
    m_createBtn->Enable(canCreate);
}
 
void BehaviorTreeProjectDialog::OnCreate(wxCommandEvent &event) {
    // Ensure we have a valid name
    wxString name = m_projectName->GetValue().Trim();
    if (name.IsEmpty()) {
        wxMessageBox("Please enter a project name.", "Error", wxOK | wxICON_ERROR, this);
        m_projectName->SetFocus();
        return;
    }
 
    // Validate project name (only letters and numbers)
    if (!IsValidProjectName(name)) {
        wxMessageBox("Project name can only contain letters (a-z, A-Z) and numbers (0-9).\n"
                     "No spaces, special characters, or symbols are allowed.",
                     "Invalid Project Name", wxOK | wxICON_ERROR, this);
        m_projectName->SetFocus();
        return;
    }
 
    // Ensure we have resources
    if (m_project->GetResourceCount() == 0) {
        wxMessageBox("Please add at least one XML file to the project.", "Error", wxOK | wxICON_ERROR, this);
        return;
    }
 
    // Run validation if not done yet
    if (!m_lastValidationReport) {
        ValidateAndUpdateUI();
    }
 
    // Warn about validation issues but allow proceeding
    if (!m_isValid) {
        int result = wxMessageBox("The project has validation issues. Do you want to create it anyway?\n\n"
                                  "You can still work with the project, but some features may not work correctly.",
                                  "Validation Warning", wxYES_NO | wxICON_WARNING, this);
 
        if (result != wxYES) {
            return;
        }
    }
 
    // Note: Unimplemented references will be reported by MainFrame after project loads
    // No need to show duplicate warning here
 
    EndModal(wxID_OK);
}
 
void BehaviorTreeProjectDialog::OnSave(wxCommandEvent &event) {
    // Same as create for now
    OnCreate(event);
}
 
void BehaviorTreeProjectDialog::OnCancel(wxCommandEvent &event) { EndModal(wxID_CANCEL); }
 
bool BehaviorTreeProjectDialog::IsValidProjectName(const wxString &name) const {
    if (name.IsEmpty()) {
        return false;
    }
 
    // Only letters (a-z, A-Z) and numbers (0-9) allowed
    for (size_t i = 0; i < name.Length(); ++i) {
        wxChar ch = name[i];
        if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))) {
            return false;
        }
    }
 
    return true;
}
 
void BehaviorTreeProjectDialog::OnPulseTimer(wxTimerEvent &event) {
    // Increment phase for smooth pulsing animation
    m_pulsePhase += 0.05f;
    if (m_pulsePhase > 1.0f) {
        m_pulsePhase = 0.0f;
    }
 
    UpdateFieldHighlighting();
}
 
void BehaviorTreeProjectDialog::UpdateFieldHighlighting() {
    // Calculate pulse intensity using sine wave for smooth animation
    float t = (std::sin(m_pulsePhase * 2.0f * 3.14159f) + 1.0f) * 0.5f;
 
    // Check project name field
    if (m_projectName) {
        wxString name = m_projectName->GetValue().Trim();
        if (!name.IsEmpty() && !IsValidProjectName(name)) {
            // Invalid - pulse yellow
            wxColour pulseColor = InterpolateColor(m_normalBg, m_highlightBg, t);
            m_projectName->SetBackgroundColour(pulseColor);
            m_projectName->Refresh();
        } else {
            // Valid or empty - use normal background
            m_projectName->SetBackgroundColour(m_normalBg);
            m_projectName->Refresh();
        }
    }
}
 
wxColour BehaviorTreeProjectDialog::InterpolateColor(const wxColour &color1, const wxColour &color2, float t) {
    // Clamp t to [0, 1]
    if (t < 0.0f)
        t = 0.0f;
    if (t > 1.0f)
        t = 1.0f;
 
    // Linear interpolation of RGB components
    unsigned char r = static_cast<unsigned char>(color1.Red() + t * (color2.Red() - color1.Red()));
    unsigned char g = static_cast<unsigned char>(color1.Green() + t * (color2.Green() - color1.Green()));
    unsigned char b = static_cast<unsigned char>(color1.Blue() + t * (color2.Blue() - color1.Blue()));
 
    return wxColour(r, g, b);
}
 
void BehaviorTreeProjectDialog::OnStructurePanelClick(wxMouseEvent &event) {
    // Convert click position to scrolled position
    int scrollX, scrollY;
    m_fileStructurePanel->GetViewStart(&scrollX, &scrollY);
    int scrollUnitY;
    m_fileStructurePanel->GetScrollPixelsPerUnit(nullptr, &scrollUnitY);
 
    wxPoint clickPos = event.GetPosition();
    clickPos.y += scrollY * scrollUnitY; // Adjust for scroll position
 
    // Find which item was clicked
    for (size_t i = 0; i < m_clickableItems.size(); ++i) {
        const auto &item = m_clickableItems[i];
        if (item.rect.Contains(clickPos)) {
            // Update selected item and refresh to show highlight
            m_selectedItemIndex = static_cast<int>(i);
 
            // Smart scroll: If clicking on item that's partially visible, scroll to center it
            int scrollUnitY;
            m_fileStructurePanel->GetScrollPixelsPerUnit(nullptr, &scrollUnitY);
 
            if (scrollUnitY > 0) {
                wxSize clientSize = m_fileStructurePanel->GetClientSize();
                int viewStartX, viewStartY;
                m_fileStructurePanel->GetViewStart(&viewStartX, &viewStartY);
                int visibleTop = viewStartY * scrollUnitY;
                int visibleBottom = visibleTop + clientSize.GetHeight();
 
                // Only auto-scroll if item is near the edges (top 20% or bottom 20% of visible area)
                int topThreshold = visibleTop + clientSize.GetHeight() / 5;
                int bottomThreshold = visibleBottom - clientSize.GetHeight() / 5;
 
                if (item.rect.GetTop() < topThreshold || item.rect.GetBottom() > bottomThreshold) {
                    // Scroll to center the item
                    int targetY = item.rect.GetTop() - (clientSize.GetHeight() / 2) + (item.rect.GetHeight() / 2);
                    if (targetY < 0)
                        targetY = 0;
                    m_fileStructurePanel->Scroll(0, targetY / scrollUnitY);
                }
            }
 
            m_fileStructurePanel->Refresh();
 
            switch (item.type) {
            case ClickableItem::File:
                m_warningDetailsPanel->Hide(); // Hide warning details
                m_warningDetailsPanel->GetParent()->Layout();
                LoadXMLPreview(item.filepath);
                break;
 
            case ClickableItem::Tree:
                m_warningDetailsPanel->Hide(); // Hide warning details
                m_warningDetailsPanel->GetParent()->Layout();
                LoadTreePreview(item.filepath, item.identifier);
                break;
 
            case ClickableItem::Blackboard:
                m_warningDetailsPanel->Hide(); // Hide warning details
                m_warningDetailsPanel->GetParent()->Layout();
                LoadBlackboardPreview(item.filepath, item.identifier);
                break;
 
            case ClickableItem::Warning:
                // Show warning details panel with comprehensive information
                {
                    wxString warningDetails;
 
                    // Detect type of issue based on identifier content
                    bool isUnimplementedRef = false;
                    bool isCircularRef = false;
                    bool isProjectError = false;
 
                    // Check if it's an unimplemented reference
                    for (const auto &unimp : m_lastValidationReport->unimplemented_trees) {
                        if (unimp == item.identifier) {
                            isUnimplementedRef = true;
                            break;
                        }
                    }
 
                    // Check if it's a circular reference
                    if (!isUnimplementedRef) {
                        for (const auto &circ : m_lastValidationReport->circular_references) {
                            if (circ == item.identifier) {
                                isCircularRef = true;
                                break;
                            }
                        }
                    }
 
                    // Check if it's a project-level error
                    if (!isUnimplementedRef && !isCircularRef) {
                        for (const auto &err : m_lastValidationReport->errors) {
                            if (err == item.identifier) {
                                isProjectError = true;
                                break;
                            }
                        }
                    }
 
                    // Check if it's a blackboard-related warning
                    bool isBlackboardInclude = false;
                    bool isBlackboardDuplicate = false;
                    bool isBlackboardValidation = false;
                    std::string bbIncludeName;
 
                    if (item.identifier.find("Missing blackboard include: ") == 0) {
                        isBlackboardInclude = true;
                        bbIncludeName = item.identifier.substr(28); // length of "Missing blackboard include: "
                    } else if (item.identifier.find("Duplicate blackboard ID") != std::string::npos) {
                        isBlackboardDuplicate = true;
                    } else if (item.identifier.find("Blackboard") != std::string::npos &&
                               (item.identifier.find("missing") != std::string::npos ||
                                item.identifier.find("duplicate entry key") != std::string::npos ||
                                item.identifier.find("unsupported type") != std::string::npos ||
                                item.identifier.find("malformed includes") != std::string::npos)) {
                        isBlackboardValidation = true;
                    }
 
                    if (isUnimplementedRef) {
                        warningDetails << "UNIMPLEMENTED REFERENCE WARNING\n\n";
                        warningDetails << "Issue: SubTree reference not found\n";
                        warningDetails << "Tree ID: " << item.identifier << "\n\n";
                    } else if (isCircularRef) {
                        warningDetails << "CIRCULAR DEPENDENCY ERROR\n\n";
                        warningDetails << "Issue: Circular reference detected\n";
                        warningDetails << "Chain: " << item.identifier << "\n\n";
                    } else if (isProjectError) {
                        warningDetails << "PROJECT ERROR\n\n";
                        warningDetails << "Issue: " << item.identifier << "\n\n";
                    } else if (isBlackboardInclude) {
                        warningDetails << "MISSING BLACKBOARD INCLUDE\n\n";
                        warningDetails << "Issue: Blackboard includes reference not found\n";
                        warningDetails << "Missing ID: " << bbIncludeName << "\n\n";
                    } else if (isBlackboardDuplicate) {
                        warningDetails << "DUPLICATE BLACKBOARD ID\n\n";
                        warningDetails << "Issue: " << item.identifier << "\n\n";
                    } else if (isBlackboardValidation) {
                        warningDetails << "BLACKBOARD VALIDATION ERROR\n\n";
                        warningDetails << "Issue: " << item.identifier << "\n\n";
                    } else {
                        // File-level error or warning
                        bool isError = item.identifier.find("Error") != std::string::npos ||
                                       item.identifier.find("error") != std::string::npos ||
                                       item.identifier.find("ERROR") != std::string::npos;
 
                        if (isError) {
                            warningDetails << "FILE ERROR\n\n";
                        } else {
                            warningDetails << "FILE WARNING\n\n";
                        }
                        warningDetails << "Issue: " << item.identifier << "\n\n";
                    }
 
                    if (!item.filepath.empty()) {
                        wxFileName fn(wxString::FromUTF8(item.filepath));
                        warningDetails << "File: " << fn.GetFullName() << "\n";
                        warningDetails << "Path: " << item.filepath << "\n\n";
 
                        if (isUnimplementedRef) {
                            warningDetails << "Description: The file references a SubTree with ID \"" << item.identifier
                                           << "\" ";
                            warningDetails
                                << "but no BehaviorTree with this ID exists in any of the project's XML files. ";
                            warningDetails << "This will cause a runtime error if this tree is executed.\n\n";
                            warningDetails << "Solution: Create a BehaviorTree with ID=\"" << item.identifier << "\" ";
                            warningDetails << "in one of your XML files, or fix the SubTree reference if it's a typo.";
                        } else if (isCircularRef) {
                            warningDetails << "Description: This represents a circular dependency chain where trees "
                                              "reference each other ";
                            warningDetails << "in a loop. This will cause infinite recursion at runtime.\n\n";
                            warningDetails << "Solution: Review the SubTree references in your files and break the "
                                              "circular dependency ";
                            warningDetails << "by restructuring your tree hierarchy.";
                        } else if (isBlackboardInclude) {
                            warningDetails
                                << "Description: A Blackboard in this file uses includes=\"{...}\" referencing \""
                                << bbIncludeName << "\" ";
                            warningDetails
                                << "but no Blackboard with this ID exists in any of the project's XML files. ";
                            warningDetails << "At runtime, the blackboard will be missing the included entries.\n\n";
                            warningDetails << "Solution: Create a Blackboard with ID=\"" << bbIncludeName << "\" ";
                            warningDetails << "in one of your XML files, or fix the includes reference if it's a typo.";
                        } else if (isBlackboardDuplicate) {
                            warningDetails
                                << "Description: Multiple Blackboards share the same ID across the project. ";
                            warningDetails << "This can cause unpredictable behavior as one definition may override "
                                              "the other.\n\n";
                            warningDetails << "Solution: Rename one of the duplicate Blackboard IDs to be unique, or "
                                              "merge them into a single definition.";
                        } else if (isBlackboardValidation) {
                            if (item.identifier.find("missing required") != std::string::npos) {
                                warningDetails << "Description: A Blackboard or Entry element is missing a required "
                                                  "XML attribute. ";
                                warningDetails << "All Blackboards must have an 'ID' attribute, and all Entries must "
                                                  "have 'key' and 'type' attributes.\n\n";
                                warningDetails << "Solution: Add the missing attribute to the XML element. Check the "
                                                  "syntax carefully.";
                            } else if (item.identifier.find("duplicate entry key") != std::string::npos) {
                                warningDetails
                                    << "Description: A Blackboard has multiple entries with the same key name. ";
                                warningDetails << "This can cause one entry to overwrite another.\n\n";
                                warningDetails << "Solution: Rename one of the duplicate entry keys to be unique, or "
                                                  "remove the duplicate.";
                            } else if (item.identifier.find("unsupported type") != std::string::npos) {
                                warningDetails << "Description: A Blackboard entry uses a data type that is not "
                                                  "recognized by the parser. ";
                                warningDetails << "This could be a typo or an unsupported type.\n\n";
                                warningDetails
                                    << "Solution: Check the type name for typos (e.g., 'strng' should be 'string'). ";
                                warningDetails << "Supported types include: bool, int, float, string, vec(...), "
                                                  "map(...), set(...), and custom types starting with uppercase.";
                            } else if (item.identifier.find("malformed includes") != std::string::npos) {
                                warningDetails << "Description: A Blackboard's 'includes' attribute doesn't follow the "
                                                  "correct syntax. ";
                                warningDetails << "The includes must be in the format: includes=\"{ID1 ID2 ID3}\" with "
                                                  "braces.\n\n";
                                warningDetails << "Solution: Fix the includes syntax to use curly braces around the "
                                                  "IDs: includes=\"{BLACKBOARD_ID1 BLACKBOARD_ID2}\".";
                            } else {
                                warningDetails << "Description: A blackboard validation issue was detected.\n\n";
                                warningDetails << "Solution: Review the blackboard definition and fix any syntax or "
                                                  "structural issues.";
                            }
                        } else {
                            warningDetails << "Description: This file has a validation issue that needs attention. ";
                            warningDetails << "Review the file content and fix any syntax errors, missing attributes, "
                                              "or structural problems.\n\n";
                            warningDetails << "Solution: Open the file and examine the highlighted area for issues. ";
                            warningDetails << "Common problems include malformed XML, missing required attributes, or "
                                              "invalid node types.";
                        }
 
                        m_warningDetailsPanel->SetValue(warningDetails);
                        m_warningDetailsPanel->Show();
                        m_warningDetailsPanel->GetParent()->Layout();
 
                        // Load the file and try to find the problematic line
                        std::ifstream file(item.filepath);
                        if (file.is_open()) {
                            std::string content((std::istreambuf_iterator<char>(file)),
                                                std::istreambuf_iterator<char>());
                            file.close();
 
                            int lineNumber = -1;
 
                            if (isUnimplementedRef) {
                                // Search for SubTree reference with this ID
                                std::string searchStr = "SubTree ID=\"" + item.identifier + "\"";
                                size_t pos = content.find(searchStr);
 
                                if (pos == std::string::npos) {
                                    // Try with single quotes
                                    searchStr = "SubTree ID='" + item.identifier + "'";
                                    pos = content.find(searchStr);
                                }
 
                                if (pos != std::string::npos) {
                                    // Count line number
                                    lineNumber = 1;
                                    for (size_t i = 0; i < pos; ++i) {
                                        if (content[i] == '\n') {
                                            lineNumber++;
                                        }
                                    }
                                }
                            } else if (isBlackboardInclude && !bbIncludeName.empty()) {
                                // Search for the includes attribute containing the missing reference
                                size_t pos = content.find(bbIncludeName);
                                if (pos != std::string::npos) {
                                    // Find the Blackboard line containing this include
                                    lineNumber = 1;
                                    for (size_t i = 0; i < pos; ++i) {
                                        if (content[i] == '\n') {
                                            lineNumber++;
                                        }
                                    }
                                }
                            } else if (isBlackboardDuplicate) {
                                // Extract the BB ID from the warning text
                                std::string dupId = item.identifier;
                                // "Duplicate blackboard ID within file: X" or "Duplicate blackboard ID in project: X"
                                size_t colonPos = dupId.rfind(": ");
                                if (colonPos != std::string::npos) {
                                    std::string bbId = dupId.substr(colonPos + 2);
                                    std::string searchStr = "Blackboard ID=\"" + bbId + "\"";
                                    size_t pos = content.find(searchStr);
                                    if (pos == std::string::npos) {
                                        searchStr = "Blackboard ID='" + bbId + "'";
                                        pos = content.find(searchStr);
                                    }
                                    if (pos != std::string::npos) {
                                        lineNumber = 1;
                                        for (size_t i = 0; i < pos; ++i) {
                                            if (content[i] == '\n') {
                                                lineNumber++;
                                            }
                                        }
                                    }
                                }
                            } else {
                                // Try to parse other blackboard-related errors
                                std::string identifier = item.identifier;
 
                                // "Blackboard element missing required 'ID' attribute"
                                if (identifier.find("Blackboard element missing") != std::string::npos) {
                                    // Find first <Blackboard without an ID attribute
                                    size_t pos = content.find("<Blackboard");
                                    while (pos != std::string::npos) {
                                        size_t lineEnd = content.find('>', pos);
                                        if (lineEnd != std::string::npos) {
                                            std::string tag = content.substr(pos, lineEnd - pos + 1);
                                            if (tag.find("ID=") == std::string::npos) {
                                                // Found Blackboard without ID
                                                lineNumber = 1;
                                                for (size_t i = 0; i < pos; ++i) {
                                                    if (content[i] == '\n')
                                                        lineNumber++;
                                                }
                                                break;
                                            }
                                        }
                                        pos = content.find("<Blackboard", pos + 1);
                                    }
                                }
                                // "Blackboard 'X' has Entry missing required 'key' attribute"
                                else if (identifier.find("has Entry missing required 'key'") != std::string::npos) {
                                    size_t quoteStart = identifier.find('\'');
                                    size_t quoteEnd = identifier.find('\'', quoteStart + 1);
                                    if (quoteStart != std::string::npos && quoteEnd != std::string::npos) {
                                        std::string bbId = identifier.substr(quoteStart + 1, quoteEnd - quoteStart - 1);
                                        // Find the Blackboard with this ID
                                        std::string searchStr = "Blackboard ID=\"" + bbId + "\"";
                                        size_t bbPos = content.find(searchStr);
                                        if (bbPos == std::string::npos) {
                                            searchStr = "Blackboard ID='" + bbId + "'";
                                            bbPos = content.find(searchStr);
                                        }
                                        if (bbPos != std::string::npos) {
                                            // Find <Entry without key attribute after this position
                                            size_t entryPos = content.find("<Entry", bbPos);
                                            while (entryPos != std::string::npos) {
                                                size_t lineEnd = content.find('>', entryPos);
                                                if (lineEnd != std::string::npos) {
                                                    std::string tag = content.substr(entryPos, lineEnd - entryPos + 1);
                                                    if (tag.find("key=") == std::string::npos) {
                                                        lineNumber = 1;
                                                        for (size_t i = 0; i < entryPos; ++i) {
                                                            if (content[i] == '\n')
                                                                lineNumber++;
                                                        }
                                                        break;
                                                    }
                                                }
                                                entryPos = content.find("<Entry", entryPos + 1);
                                                // Stop at next Blackboard
                                                size_t nextBB = content.find("<Blackboard", bbPos + 1);
                                                if (nextBB != std::string::npos && entryPos > nextBB)
                                                    break;
                                            }
                                        }
                                    }
                                }
                                // "Blackboard 'X' entry 'Y' missing required 'type' attribute"
                                // "Blackboard 'X' has duplicate entry key: Y"
                                // "Blackboard 'X' entry 'Y' has unsupported type: Z"
                                else if (identifier.find("entry '") != std::string::npos ||
                                         identifier.find("entry key: ") != std::string::npos) {
                                    // Extract entry key
                                    std::string entryKey;
                                    size_t keyStart = identifier.find("entry '");
                                    if (keyStart != std::string::npos) {
                                        keyStart += 7; // length of "entry '"
                                        size_t keyEnd = identifier.find('\'', keyStart);
                                        if (keyEnd != std::string::npos) {
                                            entryKey = identifier.substr(keyStart, keyEnd - keyStart);
                                        }
                                    } else {
                                        keyStart = identifier.find("entry key: ");
                                        if (keyStart != std::string::npos) {
                                            entryKey = identifier.substr(keyStart + 11); // length of "entry key: "
                                        }
                                    }
 
                                    if (!entryKey.empty()) {
                                        // Search for Entry with this key
                                        std::string searchStr = "Entry key=\"" + entryKey + "\"";
                                        size_t pos = content.find(searchStr);
                                        if (pos == std::string::npos) {
                                            searchStr = "Entry key='" + entryKey + "'";
                                            pos = content.find(searchStr);
                                        }
                                        if (pos != std::string::npos) {
                                            lineNumber = 1;
                                            for (size_t i = 0; i < pos; ++i) {
                                                if (content[i] == '\n')
                                                    lineNumber++;
                                            }
                                        }
                                    }
                                }
                                // "Blackboard 'X' has malformed includes syntax"
                                else if (identifier.find("has malformed includes syntax") != std::string::npos) {
                                    size_t quoteStart = identifier.find('\'');
                                    size_t quoteEnd = identifier.find('\'', quoteStart + 1);
                                    if (quoteStart != std::string::npos && quoteEnd != std::string::npos) {
                                        std::string bbId = identifier.substr(quoteStart + 1, quoteEnd - quoteStart - 1);
                                        std::string searchStr = "Blackboard ID=\"" + bbId + "\"";
                                        size_t pos = content.find(searchStr);
                                        if (pos == std::string::npos) {
                                            searchStr = "Blackboard ID='" + bbId + "'";
                                            pos = content.find(searchStr);
                                        }
                                        if (pos != std::string::npos) {
                                            lineNumber = 1;
                                            for (size_t i = 0; i < pos; ++i) {
                                                if (content[i] == '\n')
                                                    lineNumber++;
                                            }
                                        }
                                    }
                                }
                            }
 
                            if (lineNumber > 0) {
                                LoadXMLPreview(item.filepath, lineNumber);
                            } else {
                                LoadXMLPreview(item.filepath);
                            }
                        } else {
                            m_xmlPreviewPanel->SetReadOnly(false);
                            m_xmlPreviewPanel->SetText(
                                wxString::Format("Error: Could not open file '%s'", item.filepath));
                            m_xmlPreviewPanel->SetReadOnly(true);
                        }
                    } else {
                        // No specific file - handle different issue types
                        if (isUnimplementedRef) {
                            warningDetails << "Location: Unknown file\n\n";
                            warningDetails << "Description: The SubTree ID \"" << item.identifier
                                           << "\" is referenced ";
                            warningDetails << "somewhere in the project but no BehaviorTree with this ID exists. ";
                            warningDetails << "The specific file reference could not be determined.\n\n";
                            warningDetails << "Solution: Search your XML files for SubTree nodes with ID=\""
                                           << item.identifier << "\" ";
                            warningDetails << "and either implement the tree or fix the reference.";
                        } else if (isCircularRef) {
                            warningDetails << "Location: Multiple files\n\n";
                            warningDetails << "Description: A circular dependency has been detected in your project. ";
                            warningDetails << "The dependency chain is: " << item.identifier << "\n\n";
                            warningDetails
                                << "Solution: Review the files involved in this chain and restructure your trees ";
                            warningDetails << "to eliminate the circular reference.";
                        } else if (isProjectError) {
                            warningDetails << "Location: Project level\n\n";
                            warningDetails << "Description: This is a project-wide issue that affects the entire "
                                              "project structure.\n\n";
                            warningDetails << "Solution: Review your project configuration and ensure all required "
                                              "settings are valid.";
                        } else {
                            warningDetails << "Location: Unknown\n\n";
                            warningDetails << "Description: A validation issue was detected but its specific location "
                                              "could not be determined.\n\n";
                            warningDetails << "Solution: Review the validation report tab for more details.";
                        }
 
                        m_warningDetailsPanel->SetValue(warningDetails);
                        m_warningDetailsPanel->Show();
                        m_warningDetailsPanel->GetParent()->Layout();
 
                        // Show appropriate message in XML preview
                        m_xmlPreviewPanel->SetReadOnly(false);
                        if (isCircularRef) {
                            m_xmlPreviewPanel->SetText(wxString::Format(
                                "Circular Dependency Detected\n\n"
                                "Chain: %s\n\n"
                                "This indicates that trees reference each other in a loop, which will cause\n"
                                "infinite recursion at runtime. Review the files in your project to identify\n"
                                "and break the circular reference chain.",
                                item.identifier));
                        } else if (isProjectError) {
                            m_xmlPreviewPanel->SetText(
                                wxString::Format("Project Error\n\n"
                                                 "%s\n\n"
                                                 "This is a project-level error. Review your project settings\n"
                                                 "and configuration to resolve this issue.",
                                                 item.identifier));
                        } else {
                            m_xmlPreviewPanel->SetText(
                                wxString::Format("Validation Issue\n\n"
                                                 "%s\n\n"
                                                 "No specific file reference found.\n"
                                                 "Check the validation report tab for more details.",
                                                 item.identifier));
                        }
                        m_xmlPreviewPanel->SetReadOnly(true);
                    }
                }
                break;
            }
            return;
        }
    }
}
 
void BehaviorTreeProjectDialog::LoadXMLPreview(const std::string &filepath, int highlightLine) {
    // Read the XML file
    std::ifstream file(filepath);
    if (!file.is_open()) {
        m_xmlPreviewPanel->SetReadOnly(false);
        m_xmlPreviewPanel->SetText(wxString::Format("Error: Could not open file '%s'", filepath));
        m_xmlPreviewPanel->SetReadOnly(true);
        return;
    }
 
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();
 
    // Set the content
    m_xmlPreviewPanel->SetReadOnly(false);
    m_xmlPreviewPanel->SetText(wxString::FromUTF8(content));
 
    // Reset all text to default style (style 0)
    m_xmlPreviewPanel->StartStyling(0);
    m_xmlPreviewPanel->SetStyling(m_xmlPreviewPanel->GetLength(), 0);
 
    // If we need to highlight a specific line
    if (highlightLine > 0) {
        // Count to the line
        long pos = 0;
        int currentLine = 1;
        for (size_t i = 0; i < content.size() && currentLine < highlightLine; ++i) {
            if (content[i] == '\n') {
                currentLine++;
            }
            pos++;
        }
 
        // Find end of line
        long endPos = pos;
        while (endPos < (long)content.size() && content[endPos] != '\n') {
            endPos++;
        }
 
        // Highlight the line with warning style (style 1)
        m_xmlPreviewPanel->StartStyling(pos);
        m_xmlPreviewPanel->SetStyling(endPos - pos, 1);
 
        // Center the view on the highlighted line using SetFirstVisibleLine
        // This explicitly sets which line appears at the TOP of the viewport
        int lineNum = m_xmlPreviewPanel->LineFromPosition(pos);
        int linesOnScreen = m_xmlPreviewPanel->LinesOnScreen();
        int firstLine = lineNum - (linesOnScreen / 2);
        if (firstLine < 0)
            firstLine = 0;
 
        m_xmlPreviewPanel->SetFirstVisibleLine(firstLine);
 
        // Clear any selection (no caret highlighting)
        m_xmlPreviewPanel->SetSelection(0, 0);
    } else {
        // No highlight line - move to beginning of file
        m_xmlPreviewPanel->SetFirstVisibleLine(0);
    }
 
    // Clear any selection (no caret highlighting)
    m_xmlPreviewPanel->SetSelection(0, 0);
    m_xmlPreviewPanel->SetReadOnly(true);
}
 
void BehaviorTreeProjectDialog::LoadTreePreview(const std::string &filepath, const std::string &treeId) {
    // Read the XML file
    std::ifstream file(filepath);
    if (!file.is_open()) {
        m_xmlPreviewPanel->SetReadOnly(false);
        m_xmlPreviewPanel->SetText(wxString::Format("Error: Could not open file '%s'", filepath));
        m_xmlPreviewPanel->SetReadOnly(true);
        return;
    }
 
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();
 
    // Set the entire file content
    m_xmlPreviewPanel->SetReadOnly(false);
    m_xmlPreviewPanel->SetText(wxString::FromUTF8(content));
 
    // Reset all text to default style (style 0)
    m_xmlPreviewPanel->StartStyling(0);
    m_xmlPreviewPanel->SetStyling(m_xmlPreviewPanel->GetLength(), 0);
 
    // Find the BehaviorTree with this ID
    std::string searchStr = "BehaviorTree ID=\"" + treeId + "\"";
    size_t treeStartPos = content.find(searchStr);
 
    if (treeStartPos == std::string::npos) {
        // Try with single quotes
        searchStr = "BehaviorTree ID='" + treeId + "'";
        treeStartPos = content.find(searchStr);
    }
 
    if (treeStartPos != std::string::npos) {
        // Find the start of the line
        size_t lineStartPos = treeStartPos;
        while (lineStartPos > 0 && content[lineStartPos - 1] != '\n') {
            lineStartPos--;
        }
 
        // Find the closing tag
        size_t treeEndPos = content.find("</BehaviorTree>", treeStartPos);
        if (treeEndPos != std::string::npos) {
            // Find the end of the closing tag line
            treeEndPos = content.find('>', treeEndPos);
            if (treeEndPos != std::string::npos) {
                treeEndPos++; // Include the '>'
 
                // Highlight this tree section with green style (style 2)
                m_xmlPreviewPanel->StartStyling(lineStartPos);
                m_xmlPreviewPanel->SetStyling(treeEndPos - lineStartPos, 2);
 
                // Center the view on the start of the highlighted tree
                // Use SetFirstVisibleLine to explicitly position the viewport
                int treeLineNum = m_xmlPreviewPanel->LineFromPosition(lineStartPos);
                int treeEndLineNum = m_xmlPreviewPanel->LineFromPosition(treeEndPos);
                int linesOnScreen = m_xmlPreviewPanel->LinesOnScreen();
 
                // Calculate how many lines the tree spans
                int treeLines = treeEndLineNum - treeLineNum + 1;
 
                int firstLine;
                if (treeLines <= linesOnScreen) {
                    // Tree fits on screen: center it vertically
                    int middleLine = treeLineNum + (treeLines / 2);
                    firstLine = middleLine - (linesOnScreen / 2);
                } else {
                    // Tree is bigger than viewport: show from the start with a small margin
                    firstLine = treeLineNum - 2;
                }
                if (firstLine < 0)
                    firstLine = 0;
 
                m_xmlPreviewPanel->SetFirstVisibleLine(firstLine);
 
                // Clear any selection (no caret highlighting)
                m_xmlPreviewPanel->SetSelection(0, 0);
                m_xmlPreviewPanel->SetReadOnly(true);
                return;
            }
        }
    }
 
    // If we couldn't find the tree, move to beginning
    m_xmlPreviewPanel->SetFirstVisibleLine(0);
 
    // Clear any selection (no caret highlighting)
    m_xmlPreviewPanel->SetSelection(0, 0);
    m_xmlPreviewPanel->SetReadOnly(true);
}
 
void BehaviorTreeProjectDialog::LoadBlackboardPreview(const std::string &filepath, const std::string &blackboardId) {
    // Read the XML file
    std::string resolvedPath = m_project->ResolveResourcePath(filepath);
    std::ifstream file(resolvedPath);
    if (!file.is_open()) {
        m_xmlPreviewPanel->SetReadOnly(false);
        m_xmlPreviewPanel->SetText(wxString::Format("Error: Could not open file '%s'", resolvedPath));
        m_xmlPreviewPanel->SetReadOnly(true);
        return;
    }
 
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();
 
    // Set the entire file content
    m_xmlPreviewPanel->SetReadOnly(false);
    m_xmlPreviewPanel->SetText(wxString::FromUTF8(content));
 
    // Reset all text to default style (style 0)
    m_xmlPreviewPanel->StartStyling(0);
    m_xmlPreviewPanel->SetStyling(m_xmlPreviewPanel->GetLength(), 0);
 
    // Find the Blackboard with this ID
    std::string searchStr = "Blackboard ID=\"" + blackboardId + "\"";
    size_t bbStartPos = content.find(searchStr);
 
    if (bbStartPos == std::string::npos) {
        // Try with single quotes
        searchStr = "Blackboard ID='" + blackboardId + "'";
        bbStartPos = content.find(searchStr);
    }
 
    if (bbStartPos != std::string::npos) {
        // Find the start of the line
        size_t lineStartPos = bbStartPos;
        while (lineStartPos > 0 && content[lineStartPos - 1] != '\n') {
            lineStartPos--;
        }
 
        // Find the closing tag
        size_t bbEndPos = content.find("</Blackboard>", bbStartPos);
        if (bbEndPos != std::string::npos) {
            // Find the end of the closing tag line
            bbEndPos = content.find('>', bbEndPos);
            if (bbEndPos != std::string::npos) {
                bbEndPos++; // Include the '>'
 
                // Highlight this blackboard section with purple style (style 3)
                m_xmlPreviewPanel->StartStyling(lineStartPos);
                m_xmlPreviewPanel->SetStyling(bbEndPos - lineStartPos, 3);
 
                // Center the view on the start of the highlighted blackboard
                int bbLineNum = m_xmlPreviewPanel->LineFromPosition(lineStartPos);
                int bbEndLineNum = m_xmlPreviewPanel->LineFromPosition(bbEndPos);
                int linesOnScreen = m_xmlPreviewPanel->LinesOnScreen();
 
                int bbLines = bbEndLineNum - bbLineNum + 1;
 
                int firstLine;
                if (bbLines <= linesOnScreen) {
                    int middleLine = bbLineNum + (bbLines / 2);
                    firstLine = middleLine - (linesOnScreen / 2);
                } else {
                    firstLine = bbLineNum - 2;
                }
                if (firstLine < 0)
                    firstLine = 0;
 
                m_xmlPreviewPanel->SetFirstVisibleLine(firstLine);
 
                // Clear any selection
                m_xmlPreviewPanel->SetSelection(0, 0);
                m_xmlPreviewPanel->SetReadOnly(true);
                return;
            }
        }
    }
 
    // If we couldn't find the blackboard, move to beginning
    m_xmlPreviewPanel->SetFirstVisibleLine(0);
    m_xmlPreviewPanel->SetSelection(0, 0);
    m_xmlPreviewPanel->SetReadOnly(true);
}