ParserConfigDialog.cpp

Go to the documentation of this file.

#include "Dialogs/ParserConfigDialog.h"
#include "Parsers/ConfigManager.h"
#include "Parsers/ParserConfig.h"
#include "Parsers/ParserProfile.h"
#include "Utils/Logger.h"
#include "Utils/ResourcePath.h"
#include <cmath>
#include <wx/filedlg.h>
#include <wx/filename.h>
#include <wx/gbsizer.h>
#include <wx/listctrl.h>
#include <wx/msgdlg.h>
#include <wx/statbox.h>
#include <wx/statline.h>
#include <wx/stdpaths.h>
#include <wx/textdlg.h>
 
// Helper function to get resource path
static wxString GetResourcePath(const wxString &relativePath) { return EmberForge::ResourcePath::Get(relativePath); }
 
wxBEGIN_EVENT_TABLE(ParserConfigDialog, EmberUI::ScalableDialog) EVT_LIST_ITEM_SELECTED(
    ID_PROFILE_LIST, ParserConfigDialog::OnProfileSelected) EVT_BUTTON(ID_NEW_PROFILE, ParserConfigDialog::OnNewProfile)
    EVT_BUTTON(ID_CLONE_PROFILE, ParserConfigDialog::OnCloneProfile) EVT_BUTTON(ID_DELETE_PROFILE,
                                                                                ParserConfigDialog::OnDeleteProfile)
        EVT_BUTTON(ID_IMPORT_PROFILE, ParserConfigDialog::OnImportProfile) EVT_BUTTON(
            ID_EXPORT_PROFILE, ParserConfigDialog::OnExportProfile) EVT_BUTTON(ID_SET_ACTIVE,
                                                                               ParserConfigDialog::OnSetActiveProfile)
            EVT_BUTTON(ID_ADD_CONTROL_TYPE,
                       ParserConfigDialog::OnAddControlType) EVT_BUTTON(ID_REMOVE_CONTROL_TYPE,
                                                                        ParserConfigDialog::OnRemoveControlType)
                EVT_BUTTON(ID_ADD_DECORATOR_TYPE,
                           ParserConfigDialog::OnAddDecoratorType) EVT_BUTTON(ID_REMOVE_DECORATOR_TYPE,
                                                                              ParserConfigDialog::OnRemoveDecoratorType)
                    EVT_BUTTON(ID_ADD_ACTION_TYPE,
                               ParserConfigDialog::OnAddActionType) EVT_BUTTON(ID_REMOVE_ACTION_TYPE,
                                                                               ParserConfigDialog::OnRemoveActionType)
                        EVT_BUTTON(ID_ADD_CONDITION_TYPE, ParserConfigDialog::OnAddConditionType)
                            EVT_BUTTON(ID_REMOVE_CONDITION_TYPE, ParserConfigDialog::OnRemoveConditionType)
                                EVT_BUTTON(ID_ADD_MAPPING, ParserConfigDialog::OnAddTypeMapping)
                                    EVT_BUTTON(ID_REMOVE_MAPPING, ParserConfigDialog::OnRemoveTypeMapping)
                                        EVT_CHECKBOX(ID_TOGGLE_CUSTOM_VALIDATION,
                                                     ParserConfigDialog::OnToggleCustomValidation)
                                            EVT_BUTTON(ID_TEST_VALIDATE, ParserConfigDialog::OnTestValidate)
                                                EVT_BUTTON(ID_PREVIEW_JSON, ParserConfigDialog::OnPreviewJSON)
                                                    EVT_BUTTON(ID_RESET_DEFAULTS, ParserConfigDialog::OnResetDefaults)
                                                        EVT_BUTTON(ID_SAVE, ParserConfigDialog::OnSave)
                                                            EVT_BUTTON(ID_SAVE_AS, ParserConfigDialog::OnSaveAs)
                                                                EVT_BUTTON(wxID_CANCEL, ParserConfigDialog::OnCancel)
                                                                    EVT_TIMER(ID_PULSE_TIMER,
                                                                              ParserConfigDialog::OnPulseTimer)
                                                                        wxEND_EVENT_TABLE()
 
                                                                            ParserConfigDialog::ParserConfigDialog(
                                                                                wxWindow *parent)
    : EmberUI::ScalableDialog(parent, wxID_ANY, "Parser Configuration", wxSize(1400, 1000)), m_currentProfile(nullptr),
      m_modified(false), m_pulseTimer(nullptr), m_pulsePhase(0.0f), m_normalBg(50, 50, 50) // Dark background
      ,
      m_highlightBg(255, 250, 150) // Soft yellow highlight
{
    CreateLayout();
    LoadProfiles();
    Centre();
 
    // Start the pulse animation timer (30ms = ~33 fps for smooth animation)
    m_pulseTimer = new wxTimer(this, ID_PULSE_TIMER);
    m_pulseTimer->Start(30);
}
 
void ParserConfigDialog::CreateLayout() {
    wxBoxSizer *mainSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Left sidebar (200px fixed width)
    wxPanel *leftPanel = CreateLeftSidebar(this);
    mainSizer->Add(leftPanel, 0, wxEXPAND | wxALL, 5);
 
    // Right panel (expandable)
    wxPanel *rightPanel = CreateRightPanel(this);
    mainSizer->Add(rightPanel, 1, wxEXPAND | wxALL, 5);
 
    SetSizer(mainSizer);
}
 
wxPanel *ParserConfigDialog::CreateLeftSidebar(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent, wxID_ANY);
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
    // Profile list
    wxStaticText *label = new wxStaticText(panel, wxID_ANY, "Profiles:");
    sizer->Add(label, 0, wxALL, 5);
 
    // Use wxListCtrl for per-item color support
    m_profileList = new wxListCtrl(panel, ID_PROFILE_LIST, wxDefaultPosition, wxDefaultSize,
                                   wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_NO_HEADER | wxBORDER_SUNKEN);
    m_profileList->SetMinSize(wxSize(200, -1));
 
    // Set larger, bold font for profile list
    wxFont profileFont = m_profileList->GetFont();
    profileFont.SetPointSize(profileFont.GetPointSize() + 2); // Larger text
    profileFont.MakeBold();                                   // Bold text
    m_profileList->SetFont(profileFont);
 
    // Add single column (header is hidden)
    m_profileList->InsertColumn(0, "Profile", wxLIST_FORMAT_LEFT, 200);
 
    sizer->Add(m_profileList, 1, wxEXPAND | wxALL, 5);
 
    // Buttons
    m_newProfileBtn = new wxButton(panel, ID_NEW_PROFILE, "New Profile");
    sizer->Add(m_newProfileBtn, 0, wxEXPAND | wxALL, 2);
 
    m_cloneProfileBtn = new wxButton(panel, ID_CLONE_PROFILE, "Clone Profile");
    sizer->Add(m_cloneProfileBtn, 0, wxEXPAND | wxALL, 2);
 
    m_deleteProfileBtn = new wxButton(panel, ID_DELETE_PROFILE, "Delete Profile");
    sizer->Add(m_deleteProfileBtn, 0, wxEXPAND | wxALL, 2);
 
    sizer->AddSpacer(10);
 
    m_importProfileBtn = new wxButton(panel, ID_IMPORT_PROFILE, "Import Profile...");
    sizer->Add(m_importProfileBtn, 0, wxEXPAND | wxALL, 2);
 
    m_exportProfileBtn = new wxButton(panel, ID_EXPORT_PROFILE, "Export Profile...");
    sizer->Add(m_exportProfileBtn, 0, wxEXPAND | wxALL, 2);
 
    sizer->AddSpacer(10);
 
    m_setActiveBtn = new wxButton(panel, ID_SET_ACTIVE, "Set as Active");
    sizer->Add(m_setActiveBtn, 0, wxEXPAND | wxALL, 2);
 
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::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(CreateDocumentStructureTab(m_notebook), "Document Structure");
    m_notebook->AddPage(CreateTreeElementsTab(m_notebook), "Tree Elements");
    m_notebook->AddPage(CreateNodeElementsTab(m_notebook), "Node Elements");
    m_notebook->AddPage(CreateNodeClassificationTab(m_notebook), "Node Classification");
    m_notebook->AddPage(CreateBlackboardTab(m_notebook), "Blackboard");
    m_notebook->AddPage(CreateAdvancedTab(m_notebook), "Advanced");
 
    sizer->Add(m_notebook, 1, wxEXPAND | wxALL, 5);
 
    // Bottom panel
    wxPanel *bottomPanel = CreateBottomPanel(panel);
    sizer->Add(bottomPanel, 0, wxEXPAND | wxALL, 5);
 
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::CreateDocumentStructureTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxGridBagSizer *sizer = new wxGridBagSizer(10, 10); // Increased from 5,5 to 10,10 for more spacing
 
    int row = 0;
 
    // Root element name
    wxBoxSizer *labelSizer1 = new wxBoxSizer(wxHORIZONTAL);
 
    // Create info button with all state images - positioned first (left)
    // Get button size dynamically from image with safety check
    wxBitmap infoNormal(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    wxBitmapButton *infoBtn1 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn1->SetBitmapHover(infoHover);
    infoBtn1->SetBitmapPressed(infoPressed);
    infoBtn1->SetBitmapDisabled(infoDisabled);
    infoBtn1->SetToolTip("Click for detailed information");
    infoBtn1->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ROOT ELEMENT NAME\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The name of the top-level XML element that wraps all behavior trees.\n"
                            "This is the outermost container in your XML file.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'root' - BehaviorTree.CPP standard format\n"
                            "  - 'BehaviorTrees' - Some Unity implementations\n"
                            "  - 'TreeCollection' - Custom formats\n\n"
                            "IMPORTANT:\n"
                            "This element MUST be present in your XML file as the outermost container.\n"
                            "All behavior tree definitions must be nested inside this root element.\n\n"
                            "EXAMPLE XML STRUCTURE:\n"
                            "  <root main_tree_to_execute=\"MainTree\">\n"
                            "    <BehaviorTree ID=\"MainTree\">\n"
                            "      <Sequence>\n"
                            "        <Action ID=\"MoveForward\"/>\n"
                            "      </Sequence>\n"
                            "    </BehaviorTree>\n"
                            "  </root>\n\n"
                            "If your XML uses a different name (e.g., <Trees>), enter that name here.";
        HelpDialog dlg(this, "Root Element Name - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer1->Add(infoBtn1, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer1->Add(new wxStaticText(panel, wxID_ANY, "Root Element Name:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer1, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 
    m_rootElement = new wxTextCtrl(panel, wxID_ANY);
    m_rootElement->SetToolTip("Top-level XML element name (e.g., 'root')");
    m_rootElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_rootElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Main tree attribute
    wxBoxSizer *labelSizer2 = new wxBoxSizer(wxHORIZONTAL);
 
    wxBitmapButton *infoBtn2 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn2->SetBitmapHover(infoHover);
    infoBtn2->SetBitmapPressed(infoPressed);
    infoBtn2->SetBitmapDisabled(infoDisabled);
    infoBtn2->SetToolTip("Click for detailed information");
    infoBtn2->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "MAIN TREE ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The attribute on the root element that specifies which behavior tree\n"
                            "should be executed first when your XML file contains multiple trees.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'main_tree_to_execute' - BehaviorTree.CPP standard\n"
                            "  - 'entry_point' - Alternative naming convention\n"
                            "  - 'start_tree' - Some custom implementations\n\n"
                            "WHY DO YOU NEED IT?\n"
                            "When your XML file contains multiple behavior tree definitions (main tree,\n"
                            "subtrees, utility trees), this attribute tells the system which one is the\n"
                            "primary entry point.\n\n"
                            "EXAMPLE:\n"
                            "  <root main_tree_to_execute=\"PlayerAI\">\n"
                            "    <BehaviorTree ID=\"PlayerAI\">\n"
                            "      <!-- This tree will be loaded first -->\n"
                            "    </BehaviorTree>\n"
                            "    <BehaviorTree ID=\"EnemyAI\">\n"
                            "      <!-- This tree is available as a subtree -->\n"
                            "    </BehaviorTree>\n"
                            "  </root>\n\n"
                            "FALLBACK BEHAVIOR:\n"
                            "If this attribute is missing or empty, the parser will automatically\n"
                            "load the first behavior tree it finds in the file.";
        HelpDialog dlg(this, "Main Tree Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer2->Add(infoBtn2, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer2->Add(new wxStaticText(panel, wxID_ANY, "Main Tree Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer2, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 
    m_mainTreeAttr = new wxTextCtrl(panel, wxID_ANY);
    m_mainTreeAttr->SetToolTip("Attribute specifying entry point tree (e.g., 'main_tree_to_execute')");
    m_mainTreeAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_mainTreeAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Case sensitive
    wxBoxSizer *caseSizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxBitmapButton *infoBtn3 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn3->SetBitmapHover(infoHover);
    infoBtn3->SetBitmapPressed(infoPressed);
    infoBtn3->SetBitmapDisabled(infoDisabled);
    infoBtn3->SetToolTip("Click for detailed information");
    infoBtn3->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "CASE SENSITIVE ELEMENT NAMES\n"
                            "===========================================================\n\n"
                            "Controls whether element and attribute names must match the exact\n"
                            "case specified in your configuration.\n\n"
                            "ENABLED (Recommended):\n"
                            "  - <BehaviorTree> and <behaviortree> are treated as DIFFERENT\n"
                            "  - More strict parsing - catches typos and inconsistencies\n"
                            "  - Standard for most XML parsers and behavior tree formats\n"
                            "  - Best for well-defined, consistent XML formats\n\n"
                            "DISABLED:\n"
                            "  - <BehaviorTree>, <behaviortree>, <BEHAVIORTREE> all treated as SAME\n"
                            "  - More forgiving - useful for legacy/inconsistent XML files\n"
                            "  - May hide formatting issues in your XML\n"
                            "  - Use ONLY if your XML has inconsistent casing\n\n"
                            "EXAMPLE:\n"
                            "If ENABLED and you configure 'BehaviorTree' as the tree element:\n"
                            "  [YES] <BehaviorTree ID=\"Test\"> - ACCEPTED\n"
                            "  [NO]  <behaviortree ID=\"Test\"> - REJECTED (case mismatch)\n\n"
                            "If DISABLED:\n"
                            "  [YES] <BehaviorTree ID=\"Test\"> - ACCEPTED\n"
                            "  [YES] <behaviortree ID=\"Test\"> - ACCEPTED\n"
                            "  [YES] <BEHAVIORTREE ID=\"Test\"> - ACCEPTED\n\n"
                            "RECOMMENDATION:\n"
                            "Keep this ENABLED unless working with legacy files that have\n"
                            "inconsistent casing. Strict validation helps catch errors early!";
        HelpDialog dlg(this, "Case Sensitive - Help", helpText);
        dlg.ShowModal();
    });
    caseSizer->Add(infoBtn3, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_caseSensitive = new wxCheckBox(panel, wxID_ANY, "Case Sensitive Element Names");
    m_caseSensitive->SetToolTip("Element/attribute names must match exact case");
    caseSizer->Add(m_caseSensitive, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(caseSizer, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // Allow unknown elements
    wxBoxSizer *unknownSizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxBitmapButton *infoBtn4 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn4->SetBitmapHover(infoHover);
    infoBtn4->SetBitmapPressed(infoPressed);
    infoBtn4->SetBitmapDisabled(infoDisabled);
    infoBtn4->SetToolTip("Click for detailed information");
    infoBtn4->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ALLOW UNKNOWN ELEMENTS\n"
                            "===========================================================\n\n"
                            "Controls how the parser handles XML elements that are NOT defined\n"
                            "in your configuration.\n\n"
                            "ENABLED:\n"
                            "  - Unknown elements are SILENTLY IGNORED\n"
                            "  - Parsing continues without warnings\n"
                            "  - Useful for XML with documentation, metadata, or extensions\n"
                            "  - More flexible for varying XML formats\n\n"
                            "DISABLED (Recommended):\n"
                            "  - Unknown elements cause WARNING messages in the log\n"
                            "  - Helps catch typos (e.g., 'Behaviortree' vs 'BehaviorTree')\n"
                            "  - Stricter validation ensures XML matches expectations\n"
                            "  - Better for catching configuration errors\n\n"
                            "EXAMPLE - XML with unknown elements:\n"
                            "  <root>\n"
                            "    <BehaviorTree ID=\"Test\">...</BehaviorTree>\n"
                            "    <Documentation>Comment</Documentation>  <- Unknown\n"
                            "    <Metadata author=\"John\"/>  <- Unknown\n"
                            "  </root>\n\n"
                            "If ENABLED: Parser ignores <Documentation> and <Metadata>\n"
                            "If DISABLED: Parser logs warnings about unexpected elements\n\n"
                            "RECOMMENDATION:\n"
                            "Keep DISABLED during development to catch errors.\n"
                            "Enable only if you need to parse XML with extra metadata.";
        HelpDialog dlg(this, "Allow Unknown Elements - Help", helpText);
        dlg.ShowModal();
    });
    unknownSizer->Add(infoBtn4, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_allowUnknownElements = new wxCheckBox(panel, wxID_ANY, "Allow Unknown Elements");
    m_allowUnknownElements->SetToolTip("Silently ignore unrecognized XML elements");
    unknownSizer->Add(m_allowUnknownElements, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(unknownSizer, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // Whitespace handling
    wxBoxSizer *labelSizer5 = new wxBoxSizer(wxHORIZONTAL);
 
    wxBitmapButton *infoBtn5 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn5->SetBitmapHover(infoHover);
    infoBtn5->SetBitmapPressed(infoPressed);
    infoBtn5->SetBitmapDisabled(infoDisabled);
    infoBtn5->SetToolTip("Click for detailed information");
    infoBtn5->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "WHITESPACE HANDLING\n"
                            "===========================================================\n\n"
                            "Controls how whitespace (spaces, tabs, newlines) in attribute values\n"
                            "and text content is processed during parsing.\n\n"
                            "OPTIONS:\n\n"
                            "PRESERVE:\n"
                            "  - Keeps ALL whitespace exactly as it appears\n"
                            "  - '  Hello World  ' stays as '  Hello World  '\n"
                            "  - Use if whitespace is meaningful in your data\n"
                            "  - Rarely needed for behavior trees\n\n"
                            "TRIM (Recommended):\n"
                            "  - Removes leading and trailing whitespace ONLY\n"
                            "  - '  Hello World  ' becomes 'Hello World'\n"
                            "  - Internal spaces preserved: 'Hello World' stays 'Hello World'\n"
                            "  - Best for most behavior tree formats\n"
                            "  - Handles formatting inconsistencies gracefully\n\n"
                            "NORMALIZE:\n"
                            "  - Trims AND collapses multiple spaces to single space\n"
                            "  - '  Hello    World  ' becomes 'Hello World'\n"
                            "  - Useful for cleaning poorly formatted XML\n"
                            "  - May affect intentional multi-spacing\n\n"
                            "EXAMPLES:\n\n"
                            "Value: name='  Patrol Enemy  '\n"
                            "  - PRESERVE:  '  Patrol Enemy  '\n"
                            "  - TRIM:      'Patrol Enemy'\n"
                            "  - NORMALIZE: 'Patrol Enemy'\n\n"
                            "Value: name='Move    To    Target'\n"
                            "  - PRESERVE:  'Move    To    Target'\n"
                            "  - TRIM:      'Move    To    Target'\n"
                            "  - NORMALIZE: 'Move To Target'\n\n"
                            "RECOMMENDATION:\n"
                            "Use TRIM for clean, consistent parsing that handles\n"
                            "formatting variations without losing meaningful content.";
        HelpDialog dlg(this, "Whitespace Handling - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer5->Add(infoBtn5, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer5->Add(new wxStaticText(panel, wxID_ANY, "Whitespace Handling:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer5, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 
    wxArrayString whitespaceChoices;
    whitespaceChoices.Add("Preserve");
    whitespaceChoices.Add("Trim");
    whitespaceChoices.Add("Normalize");
    m_whitespaceHandling = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, whitespaceChoices);
    m_whitespaceHandling->SetSelection(1); // Trim by default
    m_whitespaceHandling->SetToolTip("How to process spaces/tabs/newlines (Trim recommended)");
    sizer->Add(m_whitespaceHandling, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Naming Convention
    wxBoxSizer *namingSizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxBitmapButton *infoBtn6 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn6->SetBitmapHover(infoHover);
    infoBtn6->SetBitmapPressed(infoPressed);
    infoBtn6->SetBitmapDisabled(infoDisabled);
    infoBtn6->SetToolTip("Click for detailed information");
    infoBtn6->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "NAMING CONVENTION\n"
                            "===========================================================\n\n"
                            "Controls how strictly element and attribute naming rules are enforced.\n"
                            "When you switch conventions, all fields are immediately re-validated\n"
                            "and invalid names are highlighted with a pulsing yellow background.\n\n"
                            "===========================================================\n\n"
                            "STRICT MODE:\n"
                            "  Allowed: Letters (a-z, A-Z) and underscores (_) ONLY\n"
                            "  Not allowed: Numbers, hyphens, dots, or any special characters\n"
                            "  Must start with: Letter or underscore\n"
                            "  \n"
                            "  Use for: Maximum safety and consistency\n"
                            "  Best for: Production environments, strict standards\n\n"
                            "===========================================================\n\n"
                            "BALANCED MODE (Recommended):\n"
                            "  Allowed: Letters, underscores, digits (0-9), and hyphens (-)\n"
                            "  Not allowed: Dots, spaces, or other special characters\n"
                            "  Must start with: Letter or underscore (NOT a number)\n"
                            "  \n"
                            "  Use for: Most projects - flexible yet safe\n"
                            "  Best for: Standard behavior tree projects\n\n"
                            "===========================================================\n\n"
                            "LOOSE MODE:\n"
                            "  Allowed: Most characters that don't break XML\n"
                            "  Includes: Letters, digits, underscores, hyphens, dots, colons\n"
                            "  Not allowed: <, >, &, quotes, spaces, brackets, and other\n"
                            "               XML-breaking characters\n"
                            "  Must start with: Letter, underscore, or colon\n"
                            "  \n"
                            "  Use for: Legacy XML files, maximum compatibility\n"
                            "  Best for: Working with existing/legacy systems\n\n"
                            "===========================================================\n\n"
                            "EXAMPLES:\n\n"
                            "Name: 'MyAction'           All modes accept\n"
                            "Name: 'My_Action'          All modes accept\n"
                            "Name: 'My-Action'          STRICT rejects  |  BALANCED/LOOSE accept\n"
                            "Name: 'MyAction123'        STRICT rejects  |  BALANCED/LOOSE accept\n"
                            "Name: 'My.Action'          STRICT/BALANCED reject  |  LOOSE accepts\n"
                            "Name: 'My:Action'          STRICT/BALANCED reject  |  LOOSE accepts\n"
                            "Name: '123Action'          STRICT/BALANCED reject  |  LOOSE rejects\n"
                            "Name: 'My Action'          All modes reject (contains space)\n"
                            "Name: 'My<Action>'         All modes reject (breaks XML)\n\n"
                            "===========================================================\n\n"
                            "LIVE VALIDATION:\n"
                            "  - Switch between conventions to see which fields become invalid\n"
                            "  - Invalid fields pulse with yellow highlighting\n"
                            "  - Fix invalid names before saving your configuration\n\n"
                            "RECOMMENDATION:\n"
                            "Start with BALANCED - it provides excellent validation while\n"
                            "supporting common naming patterns like 'Action-Name' and 'Node123'.\n"
                            "Use STRICT for maximum safety or LOOSE for legacy compatibility.";
        HelpDialog dlg(this, "Naming Convention - Help", helpText);
        dlg.ShowModal();
    });
    namingSizer->Add(infoBtn6, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    namingSizer->Add(new wxStaticText(panel, wxID_ANY, "Naming Convention:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(namingSizer, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 
    // Create a horizontal box for the three checkboxes with labels below
    wxBoxSizer *checkboxesSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Strict checkbox with label
    wxBoxSizer *strictSizer = new wxBoxSizer(wxVERTICAL);
    m_namingConventionStrict = new wxCheckBox(panel, wxID_ANY, "");
    m_namingConventionStrict->SetToolTip("Strict naming validation");
    strictSizer->Add(m_namingConventionStrict, 0, wxALIGN_CENTER_HORIZONTAL);
    strictSizer->Add(new wxStaticText(panel, wxID_ANY, "Strict"), 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 2);
    checkboxesSizer->Add(strictSizer, 0, wxRIGHT, 15);
 
    // Balanced checkbox with label
    wxBoxSizer *balancedSizer = new wxBoxSizer(wxVERTICAL);
    m_namingConventionBalanced = new wxCheckBox(panel, wxID_ANY, "");
    m_namingConventionBalanced->SetToolTip("Balanced naming validation (recommended)");
    balancedSizer->Add(m_namingConventionBalanced, 0, wxALIGN_CENTER_HORIZONTAL);
    balancedSizer->Add(new wxStaticText(panel, wxID_ANY, "Balanced"), 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 2);
    checkboxesSizer->Add(balancedSizer, 0, wxRIGHT, 15);
 
    // Loose checkbox with label
    wxBoxSizer *looseSizer = new wxBoxSizer(wxVERTICAL);
    m_namingConventionLoose = new wxCheckBox(panel, wxID_ANY, "");
    m_namingConventionLoose->SetToolTip("Loose naming validation");
    looseSizer->Add(m_namingConventionLoose, 0, wxALIGN_CENTER_HORIZONTAL);
    looseSizer->Add(new wxStaticText(panel, wxID_ANY, "Loose"), 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, 2);
    checkboxesSizer->Add(looseSizer, 0);
 
    sizer->Add(checkboxesSizer, wxGBPosition(row, 1), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    row++;
 
    // Bind checkbox events to ensure only one is selected at a time
    // and trigger validation when convention changes
    m_namingConventionStrict->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent &event) {
        if (event.IsChecked()) {
            m_namingConventionBalanced->SetValue(false);
            m_namingConventionLoose->SetValue(false);
        }
        OnNamingConventionChanged(event);
    });
    m_namingConventionBalanced->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent &event) {
        if (event.IsChecked()) {
            m_namingConventionStrict->SetValue(false);
            m_namingConventionLoose->SetValue(false);
        }
        OnNamingConventionChanged(event);
    });
    m_namingConventionLoose->Bind(wxEVT_CHECKBOX, [this](wxCommandEvent &event) {
        if (event.IsChecked()) {
            m_namingConventionStrict->SetValue(false);
            m_namingConventionBalanced->SetValue(false);
        }
        OnNamingConventionChanged(event);
    });
 
    sizer->AddGrowableCol(1);
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::CreateTreeElementsTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxGridBagSizer *sizer = new wxGridBagSizer(5, 5);
 
    // Load info button bitmaps
    wxBitmap infoNormal(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    int row = 0;
 
    // Behavior tree element
    wxBoxSizer *labelSizer1 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn1 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn1->SetBitmapHover(infoHover);
    infoBtn1->SetBitmapPressed(infoPressed);
    infoBtn1->SetBitmapDisabled(infoDisabled);
    infoBtn1->SetToolTip("Click for detailed information");
    infoBtn1->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "BEHAVIOR TREE ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents a behavior tree definition\n"
                            "in your XML file. This is the main container for each tree.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'BehaviorTree' - Standard BehaviorTree.CPP format\n"
                            "  - 'Tree' - Simplified/custom format\n"
                            "  - 'btree' - Alternative naming\n\n"
                            "HOW IT WORKS:\n"
                            "The parser scans your XML looking for elements with this exact name.\n"
                            "Each matching element is treated as a separate behavior tree definition.\n\n"
                            "EXAMPLE:\n"
                            "  <root>\n"
                            "    <BehaviorTree ID=\"MainTree\">\n"
                            "      <Sequence>\n"
                            "        <Action name=\"DoSomething\"/>\n"
                            "      </Sequence>\n"
                            "    </BehaviorTree>\n"
                            "  </root>\n\n"
                            "IMPORTANT:\n"
                            "  - Name must match EXACTLY (case-sensitive if enabled)\n"
                            "  - All your behavior trees must use this element name\n"
                            "  - Typical values: 'BehaviorTree', 'Tree', or custom names";
        HelpDialog dlg(this, "Behavior Tree Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer1->Add(infoBtn1, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer1->Add(new wxStaticText(panel, wxID_ANY, "Behavior Tree Element:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer1, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_behaviorTreeElement = new wxTextCtrl(panel, wxID_ANY);
    m_behaviorTreeElement->SetToolTip("Element name for behavior trees (e.g., 'BehaviorTree')");
    m_behaviorTreeElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_behaviorTreeElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Tree ID attribute
    wxBoxSizer *labelSizer2 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn2 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn2->SetBitmapHover(infoHover);
    infoBtn2->SetBitmapPressed(infoPressed);
    infoBtn2->SetBitmapDisabled(infoDisabled);
    infoBtn2->SetToolTip("Click for detailed information");
    infoBtn2->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "TREE ID ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that contains the unique identifier for\n"
                            "each behavior tree in your file.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'ID' - Standard BehaviorTree.CPP format (most common)\n"
                            "  - 'name' - Alternative naming convention\n"
                            "  - 'id' - Lowercase variant\n"
                            "  - 'tree_id' - Explicit naming\n\n"
                            "WHY DO YOU NEED IT?\n"
                            "The ID serves multiple critical purposes:\n"
                            "  - Uniquely identifies each behavior tree\n"
                            "  - Enables subtree references (one tree calling another)\n"
                            "  - Supports multiple trees in a single XML file\n"
                            "  - Used by the main tree attribute to specify entry point\n\n"
                            "EXAMPLE:\n"
                            "  <BehaviorTree ID=\"MainTree\">\n"
                            "    <SubTree ID=\"PatrolBehavior\"/>\n"
                            "  </BehaviorTree>\n"
                            "  <BehaviorTree ID=\"PatrolBehavior\">\n"
                            "    <!-- This tree can be called by MainTree -->\n"
                            "  </BehaviorTree>\n\n"
                            "IMPORTANT:\n"
                            "  - Each tree MUST have a unique ID\n"
                            "  - IDs are used for subtree references";
        HelpDialog dlg(this, "Tree ID Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer2->Add(infoBtn2, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer2->Add(new wxStaticText(panel, wxID_ANY, "Tree ID Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer2, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_treeIdAttr = new wxTextCtrl(panel, wxID_ANY);
    m_treeIdAttr->SetToolTip("Attribute name for tree identifier (e.g., 'ID')");
    m_treeIdAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_treeIdAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Allow multiple trees
    wxBoxSizer *labelSizer3 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn3 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn3->SetBitmapHover(infoHover);
    infoBtn3->SetBitmapPressed(infoPressed);
    infoBtn3->SetBitmapDisabled(infoDisabled);
    infoBtn3->SetToolTip("Click for detailed information");
    infoBtn3->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ALLOW MULTIPLE TREES IN FILE\n"
                            "===========================================================\n\n"
                            "Controls whether your XML file can contain multiple behavior tree\n"
                            "definitions or just one.\n\n"
                            "ENABLED (Recommended):\n"
                            "  - Multiple <BehaviorTree> elements can exist in one file\n"
                            "  - Each tree MUST have a unique ID\n"
                            "  - Perfect for organizing related trees together\n"
                            "  - Enables subtree references within the same file\n"
                            "  - Common in BehaviorTree.CPP and complex AI systems\n\n"
                            "DISABLED:\n"
                            "  - Only ONE <BehaviorTree> element allowed per file\n"
                            "  - Simpler structure for basic projects\n"
                            "  - Parser will REJECT files with multiple trees\n"
                            "  - Forces one-tree-per-file organization\n\n"
                            "EXAMPLE (ENABLED):\n"
                            "  <root>\n"
                            "    <BehaviorTree ID=\"MainAI\">\n"
                            "      <SubTree ID=\"Patrol\"/>\n"
                            "    </BehaviorTree>\n"
                            "    <BehaviorTree ID=\"Patrol\">\n"
                            "      <!-- Subtree definition -->\n"
                            "    </BehaviorTree>\n"
                            "  </root>\n\n"
                            "RECOMMENDATION:\n"
                            "Enable this for flexibility and better tree organization.";
        HelpDialog dlg(this, "Allow Multiple Trees - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer3->Add(infoBtn3, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_allowMultipleTrees = new wxCheckBox(panel, wxID_ANY, "Allow Multiple Trees in File");
    m_allowMultipleTrees->SetToolTip("Whether XML can contain multiple behavior tree definitions");
    labelSizer3->Add(m_allowMultipleTrees, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer3, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // Subtree element
    wxBoxSizer *labelSizer4 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn4 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn4->SetBitmapHover(infoHover);
    infoBtn4->SetBitmapPressed(infoPressed);
    infoBtn4->SetBitmapDisabled(infoDisabled);
    infoBtn4->SetToolTip("Click for detailed information");
    infoBtn4->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "SUBTREE ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents a subtree reference - a special\n"
                            "node that calls another behavior tree by its ID.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'SubTree' - Standard BehaviorTree.CPP format (recommended)\n"
                            "  - 'CallTree' - Alternative naming\n"
                            "  - 'TreeReference' - Explicit variant\n"
                            "  - 'Include' - Some custom implementations\n\n"
                            "HOW IT WORKS:\n"
                            "When the execution reaches a SubTree node, it:\n"
                            "  1. Pauses the current tree\n"
                            "  2. Executes the referenced tree completely\n"
                            "  3. Returns the referenced tree's result (SUCCESS/FAILURE)\n"
                            "  4. Continues with the current tree\n\n"
                            "EXAMPLE:\n"
                            "  <BehaviorTree ID=\"MainAI\">\n"
                            "    <Sequence>\n"
                            "      <SubTree ID=\"PatrolBehavior\"/>\n"
                            "      <Action name=\"Attack\"/>\n"
                            "    </Sequence>\n"
                            "  </BehaviorTree>\n\n"
                            "BENEFITS:\n"
                            "  - Reuse trees in multiple places\n"
                            "  - Create modular, maintainable structures\n"
                            "  - Break complex behaviors into components";
        HelpDialog dlg(this, "SubTree Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer4->Add(infoBtn4, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer4->Add(new wxStaticText(panel, wxID_ANY, "SubTree Element:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer4, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_subtreeElement = new wxTextCtrl(panel, wxID_ANY);
    m_subtreeElement->SetToolTip("Element name for subtree references (e.g., 'SubTree')");
    m_subtreeElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_subtreeElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Subtree reference attribute
    wxBoxSizer *labelSizer5 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn5 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn5->SetBitmapHover(infoHover);
    infoBtn5->SetBitmapPressed(infoPressed);
    infoBtn5->SetBitmapDisabled(infoDisabled);
    infoBtn5->SetToolTip("Click for detailed information");
    infoBtn5->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "SUBTREE REFERENCE ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name on a SubTree node that contains the ID of\n"
                            "the behavior tree being referenced/called.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'ID' - Standard BehaviorTree.CPP format (most common)\n"
                            "  - 'treeID' - Explicit variant\n"
                            "  - 'ref' - Short form\n"
                            "  - 'tree' - Simple naming\n\n"
                            "HOW IT WORKS:\n"
                            "When the parser encounters a SubTree node:\n"
                            "  1. Reads this attribute to get the referenced tree ID\n"
                            "  2. Searches for a BehaviorTree with matching ID\n"
                            "  3. Links them together for execution\n"
                            "  4. Validates that the reference is valid\n\n"
                            "EXAMPLE:\n"
                            "  <BehaviorTree ID=\"MainAI\">\n"
                            "    <SubTree ID=\"PatrolBehavior\"/>\n"
                            "           ^^^^^^^^^^^^^^^^^^^^^\n"
                            "           This attribute references another tree\n"
                            "  </BehaviorTree>\n\n"
                            "IMPORTANT:\n"
                            "  - Should typically MATCH your Tree ID Attribute setting\n"
                            "  - Referenced tree must exist in the same or loaded files\n"
                            "  - Parser validates references during loading";
        HelpDialog dlg(this, "SubTree Reference Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer5->Add(infoBtn5, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer5->Add(new wxStaticText(panel, wxID_ANY, "SubTree Reference Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer5, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_subtreeRefAttr = new wxTextCtrl(panel, wxID_ANY);
    m_subtreeRefAttr->SetToolTip("Attribute containing referenced tree ID (e.g., 'ID')");
    m_subtreeRefAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_subtreeRefAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Validate structure
    wxBoxSizer *labelSizer6 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn6 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn6->SetBitmapHover(infoHover);
    infoBtn6->SetBitmapPressed(infoPressed);
    infoBtn6->SetBitmapDisabled(infoDisabled);
    infoBtn6->SetToolTip("Click for detailed information");
    infoBtn6->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "VALIDATE TREE STRUCTURE\n"
                            "===========================================================\n\n"
                            "Enables comprehensive structural validation to ensure your behavior\n"
                            "trees follow proper hierarchical and semantic rules.\n\n"
                            "ENABLED (Recommended):\n"
                            "  The parser performs these critical checks:\n"
                            "  - Control nodes (Sequence, Selector, etc.) have at least one child\n"
                            "  - Decorator nodes have EXACTLY one child\n"
                            "  - Action/Condition nodes have NO children\n"
                            "  - No circular subtree references (A->B->A)\n"
                            "  - All node types are properly nested\n"
                            "  - Tree structure matches behavior tree semantics\n\n"
                            "DISABLED:\n"
                            "  - No structural validation performed\n"
                            "  - Faster parsing (minimal performance gain)\n"
                            "  - MAY allow invalid trees that crash at runtime\n"
                            "  - Use ONLY if you're 100% certain trees are valid\n\n"
                            "BENEFITS OF ENABLING:\n"
                            "  - Catches errors EARLY during file loading\n"
                            "  - Prevents mysterious runtime crashes\n"
                            "  - Provides CLEAR, actionable error messages\n"
                            "  - Saves debugging time\n\n"
                            "RECOMMENDATION:\n"
                            "Keep this ENABLED, especially during development!";
        HelpDialog dlg(this, "Validate Tree Structure - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer6->Add(infoBtn6, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_validateStructure = new wxCheckBox(panel, wxID_ANY, "Validate Tree Structure");
    m_validateStructure->SetToolTip("Perform structural validation on parsed trees");
    labelSizer6->Add(m_validateStructure, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer6, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // Require root node
    wxBoxSizer *labelSizer7 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn7 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn7->SetBitmapHover(infoHover);
    infoBtn7->SetBitmapPressed(infoPressed);
    infoBtn7->SetBitmapDisabled(infoDisabled);
    infoBtn7->SetToolTip("Click for detailed information");
    infoBtn7->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "REQUIRE ROOT NODE\n"
                            "===========================================================\n\n"
                            "Determines whether each behavior tree must have at least one\n"
                            "root node (a direct child of the BehaviorTree element).\n\n"
                            "ENABLED (Recommended):\n"
                            "  - Each tree MUST contain at least one root-level node\n"
                            "  - Empty trees are REJECTED during parsing\n"
                            "  - Ensures all trees are executable and meaningful\n"
                            "  - Catches incomplete or placeholder trees\n"
                            "  - Standard for production-ready behavior trees\n\n"
                            "DISABLED:\n"
                            "  - Empty trees are ALLOWED (no root node required)\n"
                            "  - Useful for template/stub trees during development\n"
                            "  - May allow non-functional tree structures\n"
                            "  - Could lead to runtime issues if tree is called\n\n"
                            "EXAMPLE (VALID - with root):\n"
                            "  <BehaviorTree ID=\"MainTree\">\n"
                            "    <Sequence>  <!-- ROOT NODE (direct child) -->\n"
                            "      <Action name=\"DoSomething\"/>\n"
                            "    </Sequence>\n"
                            "  </BehaviorTree>\n\n"
                            "EXAMPLE (INVALID - no root):\n"
                            "  <BehaviorTree ID=\"EmptyTree\">\n"
                            "    <!-- No nodes! -->\n"
                            "  </BehaviorTree>\n\n"
                            "RECOMMENDATION:\n"
                            "Keep ENABLED to ensure all trees are complete and executable!";
        HelpDialog dlg(this, "Require Root Node - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer7->Add(infoBtn7, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_requireRootNode = new wxCheckBox(panel, wxID_ANY, "Require Root Node");
    m_requireRootNode->SetToolTip("Each tree must have at least one root node");
    labelSizer7->Add(m_requireRootNode, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer7, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    sizer->AddGrowableCol(1);
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::CreateNodeElementsTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxGridBagSizer *sizer = new wxGridBagSizer(5, 5);
 
    // Load info button bitmaps
    wxBitmap infoNormal(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    int row = 0;
 
    // Control element
    wxBoxSizer *labelSizer1 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn1 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn1->SetBitmapHover(infoHover);
    infoBtn1->SetBitmapPressed(infoPressed);
    infoBtn1->SetBitmapDisabled(infoDisabled);
    infoBtn1->SetToolTip("Click for detailed information");
    infoBtn1->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "CONTROL NODE ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents control flow nodes - nodes that\n"
                            "control the execution order and logic of their children.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'Control' - Generic control node element\n"
                            "  - Leave empty to use specific names (Sequence, Selector, etc.)\n\n"
                            "CONTROL NODE TYPES:\n"
                            "Control nodes determine HOW and WHEN child nodes execute:\n"
                            "  - Sequence: Execute children in order until one fails\n"
                            "  - Selector/Fallback: Execute children until one succeeds\n"
                            "  - Parallel: Execute multiple children simultaneously\n"
                            "  - Random: Execute children in random order\n\n"
                            "HOW IT WORKS:\n"
                            "If set to 'Control':\n"
                            "  <Control type=\"Sequence\">\n"
                            "    <Action name=\"Step1\"/>\n"
                            "    <Action name=\"Step2\"/>\n"
                            "  </Control>\n\n"
                            "If left empty (common in BehaviorTree.CPP):\n"
                            "  <Sequence>  <!-- Direct element name -->\n"
                            "    <Action name=\"Step1\"/>\n"
                            "  </Sequence>\n\n"
                            "RECOMMENDATION:\n"
                            "For BehaviorTree.CPP compatibility, leave empty and use\n"
                            "specific element names like <Sequence>, <Selector>, etc.";
        HelpDialog dlg(this, "Control Node Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer1->Add(infoBtn1, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer1->Add(new wxStaticText(panel, wxID_ANY, "Control Node Element:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer1, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_controlElement = new wxTextCtrl(panel, wxID_ANY);
    m_controlElement->SetToolTip("Element name for control nodes (e.g., 'Control')");
    m_controlElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_controlElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Action element
    wxBoxSizer *labelSizer2 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn2 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn2->SetBitmapHover(infoHover);
    infoBtn2->SetBitmapPressed(infoPressed);
    infoBtn2->SetBitmapDisabled(infoDisabled);
    infoBtn2->SetToolTip("Click for detailed information");
    infoBtn2->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ACTION NODE ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents action nodes - nodes that\n"
                            "perform actual tasks or operations in your behavior tree.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'Action' - Standard BehaviorTree.CPP format\n"
                            "  - 'Task' - Alternative naming\n"
                            "  - 'Do' - Simple variant\n\n"
                            "WHAT ARE ACTION NODES?\n"
                            "Actions are the LEAF NODES that do the actual work:\n"
                            "  - Move to a position\n"
                            "  - Play an animation\n"
                            "  - Attack an enemy\n"
                            "  - Wait for a duration\n"
                            "  - Set a variable\n\n"
                            "CHARACTERISTICS:\n"
                            "  - Have NO children (leaf nodes)\n"
                            "  - Return SUCCESS, FAILURE, or RUNNING\n"
                            "  - Contain the actual executable logic\n"
                            "  - May take parameters via attributes\n\n"
                            "EXAMPLE:\n"
                            "  <BehaviorTree ID=\"PatrolAI\">\n"
                            "    <Sequence>\n"
                            "      <Action name=\"MoveToWaypoint\"/>\n"
                            "      <Action name=\"Wait\" duration=\"2.0\"/>\n"
                            "      <Action name=\"LookAround\"/>\n"
                            "    </Sequence>\n"
                            "  </BehaviorTree>\n\n"
                            "RECOMMENDATION:\n"
                            "Use 'Action' for standard BehaviorTree.CPP compatibility.";
        HelpDialog dlg(this, "Action Node Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer2->Add(infoBtn2, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer2->Add(new wxStaticText(panel, wxID_ANY, "Action Node Element:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer2, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_actionElement = new wxTextCtrl(panel, wxID_ANY);
    m_actionElement->SetToolTip("Element name for action nodes (e.g., 'Action')");
    m_actionElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_actionElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Condition element
    wxBoxSizer *labelSizer3 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn3 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn3->SetBitmapHover(infoHover);
    infoBtn3->SetBitmapPressed(infoPressed);
    infoBtn3->SetBitmapDisabled(infoDisabled);
    infoBtn3->SetToolTip("Click for detailed information");
    infoBtn3->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "CONDITION NODE ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents condition nodes - nodes that\n"
                            "check/test a state and return SUCCESS or FAILURE immediately.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'Condition' - Standard BehaviorTree.CPP format\n"
                            "  - 'Check' - Alternative naming\n"
                            "  - 'Test' - Some implementations\n\n"
                            "WHAT ARE CONDITION NODES?\n"
                            "Conditions are LEAF NODES that perform instant checks:\n"
                            "  - Is enemy in range?\n"
                            "  - Is health below 50%?\n"
                            "  - Is door open?\n"
                            "  - Has item in inventory?\n"
                            "  - Is time > X?\n\n"
                            "KEY CHARACTERISTICS:\n"
                            "  - Have NO children (leaf nodes)\n"
                            "  - Execute INSTANTLY (never return RUNNING)\n"
                            "  - Return only SUCCESS or FAILURE\n"
                            "  - Used for decision-making logic\n"
                            "  - Often used with Selectors for branching\n\n"
                            "EXAMPLE:\n"
                            "  <Selector>\n"
                            "    <Sequence>\n"
                            "      <Condition name=\"IsEnemyClose\"/>\n"
                            "      <Action name=\"Attack\"/>\n"
                            "    </Sequence>\n"
                            "    <Action name=\"Patrol\"/>\n"
                            "  </Selector>\n\n"
                            "RECOMMENDATION:\n"
                            "Use 'Condition' for standard BehaviorTree.CPP compatibility.";
        HelpDialog dlg(this, "Condition Node Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer3->Add(infoBtn3, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer3->Add(new wxStaticText(panel, wxID_ANY, "Condition Node Element:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer3, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_conditionElement = new wxTextCtrl(panel, wxID_ANY);
    m_conditionElement->SetToolTip("Element name for condition nodes (e.g., 'Condition')");
    m_conditionElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_conditionElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Decorator element
    wxBoxSizer *labelSizer4 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn4 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn4->SetBitmapHover(infoHover);
    infoBtn4->SetBitmapPressed(infoPressed);
    infoBtn4->SetBitmapDisabled(infoDisabled);
    infoBtn4->SetToolTip("Click for detailed information");
    infoBtn4->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "DECORATOR NODE ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents decorator nodes - nodes that\n"
                            "modify or enhance the behavior of EXACTLY ONE child node.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'Decorator' - Generic decorator element\n"
                            "  - Leave empty to use specific names (Inverter, Retry, etc.)\n\n"
                            "WHAT ARE DECORATOR NODES?\n"
                            "Decorators WRAP a single child and modify its behavior:\n"
                            "  - Inverter: Flip SUCCESS <-> FAILURE\n"
                            "  - Retry: Repeat child until success (N times)\n"
                            "  - Repeat: Execute child multiple times\n"
                            "  - Force Success/Failure: Override child's result\n"
                            "  - Timeout: Fail child if it takes too long\n"
                            "  - Delay: Wait before executing child\n\n"
                            "KEY CHARACTERISTICS:\n"
                            "  - Must have EXACTLY ONE child\n"
                            "  - Act as a wrapper/modifier\n"
                            "  - Don't change the tree structure\n"
                            "  - Commonly used for logic inversion and retries\n\n"
                            "EXAMPLE:\n"
                            "  <Sequence>\n"
                            "    <Inverter>  <!-- Decorator: flips result -->\n"
                            "      <Condition name=\"IsEnemyClose\"/>\n"
                            "    </Inverter>\n"
                            "    <Action name=\"Patrol\"/>\n"
                            "  </Sequence>\n\n"
                            "RECOMMENDATION:\n"
                            "Leave empty and use specific names like <Inverter>, <Retry>.";
        HelpDialog dlg(this, "Decorator Node Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer4->Add(infoBtn4, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer4->Add(new wxStaticText(panel, wxID_ANY, "Decorator Node Element:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer4, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_decoratorElement = new wxTextCtrl(panel, wxID_ANY);
    m_decoratorElement->SetToolTip("Element name for decorator nodes (e.g., 'Decorator')");
    m_decoratorElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_decoratorElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Generic node element
    wxBoxSizer *labelSizer5 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn5 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn5->SetBitmapHover(infoHover);
    infoBtn5->SetBitmapPressed(infoPressed);
    infoBtn5->SetBitmapDisabled(infoDisabled);
    infoBtn5->SetToolTip("Click for detailed information");
    infoBtn5->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "GENERIC NODE ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "A fallback element name used when a node doesn't match any\n"
                            "of the specific node type elements (Control, Action, etc.).\n\n"
                            "COMMON VALUES:\n"
                            "  - 'Node' - Simple generic name\n"
                            "  - Leave empty if not needed\n\n"
                            "WHEN IS IT USED?\n"
                            "This acts as a catch-all for nodes that don't fit standard categories:\n"
                            "  - Custom node types specific to your implementation\n"
                            "  - Experimental or plugin nodes\n"
                            "  - Nodes that need runtime type determination\n\n"
                            "HOW IT WORKS:\n"
                            "Parser checks elements in this order:\n"
                            "  1. Is it a Control node? (e.g., <Sequence>)\n"
                            "  2. Is it an Action node? (e.g., <Action>)\n"
                            "  3. Is it a Condition node? (e.g., <Condition>)\n"
                            "  4. Is it a Decorator node? (e.g., <Inverter>)\n"
                            "  5. Is it the Generic element? (e.g., <Node>)\n"
                            "  6. Unknown element (error or ignored)\n\n"
                            "EXAMPLE:\n"
                            "  <Node type=\"CustomPlugin\" name=\"SpecialBehavior\">\n"
                            "    <!-- Custom implementation -->\n"
                            "  </Node>\n\n"
                            "RECOMMENDATION:\n"
                            "Leave empty unless you have custom node types that don't\n"
                            "fit the standard categories.";
        HelpDialog dlg(this, "Generic Node Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer5->Add(infoBtn5, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer5->Add(new wxStaticText(panel, wxID_ANY, "Generic Node Element:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer5, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_genericNodeElement = new wxTextCtrl(panel, wxID_ANY);
    m_genericNodeElement->SetToolTip("Fallback element name for generic nodes (e.g., 'Node')");
    m_genericNodeElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_genericNodeElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Node ID attribute
    wxBoxSizer *labelSizer6 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn6 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn6->SetBitmapHover(infoHover);
    infoBtn6->SetBitmapPressed(infoPressed);
    infoBtn6->SetBitmapDisabled(infoDisabled);
    infoBtn6->SetToolTip("Click for detailed information");
    infoBtn6->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "NODE ID ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that identifies the specific TYPE or\n"
                            "CLASS of a node (e.g., 'Sequence', 'MoveToTarget', 'IsHealthLow').\n\n"
                            "COMMON VALUES:\n"
                            "  - 'ID' - BehaviorTree.CPP standard\n"
                            "  - 'type' - Alternative common usage\n"
                            "  - 'class' - Some implementations\n\n"
                            "WHAT DOES IT CONTAIN?\n"
                            "The ID typically specifies the node's TYPE/CLASS:\n"
                            "  - For Control: 'Sequence', 'Selector', 'Parallel'\n"
                            "  - For Action: 'MoveToTarget', 'Attack', 'PlayAnimation'\n"
                            "  - For Condition: 'IsHealthLow', 'IsEnemyNear'\n"
                            "  - For Decorator: 'Inverter', 'Retry', 'Timeout'\n\n"
                            "EXAMPLE (using ID='type'):\n"
                            "  <Control ID=\"Sequence\">\n"
                            "    <Action ID=\"MoveToWaypoint\" target=\"wp1\"/>\n"
                            "    <Action ID=\"Wait\" duration=\"2.0\"/>\n"
                            "  </Control>\n\n"
                            "vs EXAMPLE (element name is type):\n"
                            "  <Sequence>\n"
                            "    <MoveToWaypoint target=\"wp1\"/>\n"
                            "    <Wait duration=\"2.0\"/>\n"
                            "  </Sequence>\n\n"
                            "RECOMMENDATION:\n"
                            "Use 'ID' for BehaviorTree.CPP compatibility when using\n"
                            "generic element names. Leave empty if using specific\n"
                            "element names for each node type.";
        HelpDialog dlg(this, "Node ID Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer6->Add(infoBtn6, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer6->Add(new wxStaticText(panel, wxID_ANY, "Node ID Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer6, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_nodeIdAttr = new wxTextCtrl(panel, wxID_ANY);
    m_nodeIdAttr->SetToolTip("Attribute name for node identifier/type (e.g., 'ID')");
    m_nodeIdAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_nodeIdAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Node name attribute
    wxBoxSizer *labelSizer7 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn7 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn7->SetBitmapHover(infoHover);
    infoBtn7->SetBitmapPressed(infoPressed);
    infoBtn7->SetBitmapDisabled(infoDisabled);
    infoBtn7->SetToolTip("Click for detailed information");
    infoBtn7->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "NODE NAME ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that provides a human-readable display\n"
                            "name or label for a node instance.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'name' - Most common standard\n"
                            "  - 'label' - Alternative\n"
                            "  - 'displayName' - Explicit variant\n\n"
                            "WHAT'S THE DIFFERENCE FROM NODE ID?\n"
                            "  - Node ID: The TYPE/CLASS of the node (e.g., 'MoveToTarget')\n"
                            "  - Node Name: A specific INSTANCE label (e.g., 'Move to Enemy')\n\n"
                            "WHY USE IT?\n"
                            "  - Provide descriptive labels in visual editors\n"
                            "  - Make trees more readable in XML\n"
                            "  - Help with debugging and logging\n"
                            "  - Distinguish between multiple instances of same node type\n\n"
                            "EXAMPLE:\n"
                            "  <Action ID=\"MoveToTarget\" name=\"Move to Waypoint 1\">\n"
                            "            ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^\n"
                            "            Node type/class  Human-readable name\n"
                            "\n"
                            "  <Action ID=\"MoveToTarget\" name=\"Return to Base\">\n"
                            "            Same type        Different instance name\n\n"
                            "IN VISUAL EDITOR:\n"
                            "The 'name' would be displayed on the node box, making the\n"
                            "tree easier to understand at a glance.\n\n"
                            "RECOMMENDATION:\n"
                            "Use 'name' for standard compatibility and readability.";
        HelpDialog dlg(this, "Node Name Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer7->Add(infoBtn7, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer7->Add(new wxStaticText(panel, wxID_ANY, "Node Name Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer7, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_nodeNameAttr = new wxTextCtrl(panel, wxID_ANY);
    m_nodeNameAttr->SetToolTip("Attribute name for node display name (e.g., 'name')");
    m_nodeNameAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_nodeNameAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Node type attribute
    wxBoxSizer *labelSizer8 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn8 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn8->SetBitmapHover(infoHover);
    infoBtn8->SetBitmapPressed(infoPressed);
    infoBtn8->SetBitmapDisabled(infoDisabled);
    infoBtn8->SetToolTip("Click for detailed information");
    infoBtn8->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "NODE TYPE ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "An ALTERNATIVE attribute used for by-attribute node classification,\n"
                            "where node category is specified via attribute instead of element name.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'type' - Most common\n"
                            "  - 'category' - Alternative\n"
                            "  - 'nodeType' - Explicit variant\n\n"
                            "WHEN IS THIS USED?\n"
                            "Some XML formats use a SINGLE generic element with a type attribute\n"
                            "instead of different elements for each node category:\n\n"
                            "BY-ELEMENT APPROACH (most common):\n"
                            "  <Sequence>\n"
                            "    <Action name=\"Move\"/>\n"
                            "    <Condition name=\"IsClose\"/>\n"
                            "  </Sequence>\n\n"
                            "BY-ATTRIBUTE APPROACH:\n"
                            "  <Node type=\"Sequence\">\n"
                            "    <Node type=\"Action\" name=\"Move\"/>\n"
                            "    <Node type=\"Condition\" name=\"IsClose\"/>\n"
                            "  </Node>\n"
                            "        ^^^^^^^^^^^^^^\n"
                            "        This attribute specifies node category\n\n"
                            "ATTRIBUTE VALUES:\n"
                            "  - 'Control', 'Action', 'Condition', 'Decorator'\n"
                            "  - Used by parser to classify nodes\n\n"
                            "RECOMMENDATION:\n"
                            "Only use this if your XML format uses by-attribute\n"
                            "classification. Leave empty for standard element-based\n"
                            "classification (BehaviorTree.CPP style).";
        HelpDialog dlg(this, "Node Type Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer8->Add(infoBtn8, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer8->Add(new wxStaticText(panel, wxID_ANY, "Node Type Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer8, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_nodeTypeAttr = new wxTextCtrl(panel, wxID_ANY);
    m_nodeTypeAttr->SetToolTip("Attribute name for node type (used in by-attribute classification)");
    m_nodeTypeAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    sizer->Add(m_nodeTypeAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Allow custom attributes
    wxBoxSizer *labelSizer9 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn9 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn9->SetBitmapHover(infoHover);
    infoBtn9->SetBitmapPressed(infoPressed);
    infoBtn9->SetBitmapDisabled(infoDisabled);
    infoBtn9->SetToolTip("Click for detailed information");
    infoBtn9->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ALLOW CUSTOM ATTRIBUTES\n"
                            "===========================================================\n\n"
                            "Controls whether the parser preserves and stores custom/additional\n"
                            "attributes found on nodes beyond the standard configuration attributes.\n\n"
                            "ENABLED (Recommended):\n"
                            "  - ALL attributes on nodes are parsed and stored\n"
                            "  - Custom parameters are preserved for runtime use\n"
                            "  - Enables flexible node parameterization\n"
                            "  - Required for most practical behavior trees\n\n"
                            "DISABLED:\n"
                            "  - Only recognized/standard attributes are stored\n"
                            "  - Custom attributes are IGNORED during parsing\n"
                            "  - Stricter validation, but less flexible\n"
                            "  - May lose important node parameters\n\n"
                            "EXAMPLE (custom attributes in bold concept):\n"
                            "  <Action name=\"MoveToTarget\" \n"
                            "          speed=\"5.0\"        <!-- Custom attribute -->\n"
                            "          target=\"enemy\"     <!-- Custom attribute -->\n"
                            "          acceptableRadius=\"2.0\">  <!-- Custom -->\n\n"
                            "WHY ENABLE?\n"
                            "  - Actions/Conditions need parameters to work\n"
                            "  - Different node instances need different values\n"
                            "  - Runtime system reads these for behavior\n"
                            "  - Standard in BehaviorTree.CPP and most frameworks\n\n"
                            "RECOMMENDATION:\n"
                            "KEEP THIS ENABLED! Most behavior trees require custom\n"
                            "attributes for node parameters, making trees functional\n"
                            "and configurable.";
        HelpDialog dlg(this, "Allow Custom Attributes - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer9->Add(infoBtn9, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_allowCustomAttrs = new wxCheckBox(panel, wxID_ANY, "Allow Custom Attributes");
    m_allowCustomAttrs->SetToolTip("Parse and store custom attributes on nodes");
    labelSizer9->Add(m_allowCustomAttrs, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer9, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    sizer->AddGrowableCol(1);
    panel->SetSizer(sizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::CreateNodeClassificationTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Load info button bitmaps
    wxBitmap infoNormal(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    // Classification strategy
    wxBoxSizer *strategySizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxBitmapButton *infoBtn1 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn1->SetBitmapHover(infoHover);
    infoBtn1->SetBitmapPressed(infoPressed);
    infoBtn1->SetBitmapDisabled(infoDisabled);
    infoBtn1->SetToolTip("Click for detailed information");
    infoBtn1->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "CLASSIFICATION STRATEGY\n"
                            "===========================================================\n\n"
                            "Determines HOW the parser identifies what type of node it's dealing\n"
                            "with when reading your XML.\n\n"
                            "THREE STRATEGIES:\n\n"
                            "1. BY ELEMENT NAME (Most Common)\n"
                            "   - Node type is determined by the XML element name itself\n"
                            "   - Different elements for different types\n"
                            "   Example:\n"
                            "     <Sequence>        <!-- Control node -->\n"
                            "       <Action name=\"Move\"/>    <!-- Action node -->\n"
                            "       <Condition name=\"Check\"/> <!-- Condition node -->\n"
                            "     </Sequence>\n"
                            "   Pros: Clean, readable XML; standard in BehaviorTree.CPP\n"
                            "   Use when: You want clear, self-documenting trees\n\n"
                            "2. BY ATTRIBUTE\n"
                            "   - Single generic element with 'type' attribute\n"
                            "   - All nodes use the same element name\n"
                            "   Example:\n"
                            "     <Node type=\"Sequence\">\n"
                            "       <Node type=\"Action\" name=\"Move\"/>\n"
                            "       <Node type=\"Condition\" name=\"Check\"/>\n"
                            "     </Node>\n"
                            "   Pros: Uniform structure; easier schema validation\n"
                            "   Use when: You need strict XML schema conformance\n\n"
                            "3. HYBRID\n"
                            "   - Mix of both approaches\n"
                            "   - Checks element name first, falls back to attribute\n"
                            "   Example:\n"
                            "     <Sequence>        <!-- By element name -->\n"
                            "       <Node type=\"Action\" name=\"Custom\"/> <!-- By attribute -->\n"
                            "       <Condition name=\"Check\"/>  <!-- By element name -->\n"
                            "     </Sequence>\n"
                            "   Pros: Maximum flexibility; supports mixed formats\n"
                            "   Use when: Working with multiple XML formats\n\n"
                            "RECOMMENDATION:\n"
                            "Use 'By Element Name' for standard BehaviorTree.CPP compatibility\n"
                            "and maximum readability.";
        HelpDialog dlg(this, "Classification Strategy - Help", helpText);
        dlg.ShowModal();
    });
    strategySizer->Add(infoBtn1, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
    strategySizer->Add(new wxStaticText(panel, wxID_ANY, "Classification Strategy:"), 0,
                       wxALIGN_CENTER_VERTICAL | wxALL, 5);
    wxArrayString strategyChoices;
    strategyChoices.Add("By Element Name");
    strategyChoices.Add("By Attribute");
    strategyChoices.Add("Hybrid");
    m_classificationStrategy = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, strategyChoices);
    m_classificationStrategy->SetSelection(0);
    strategySizer->Add(m_classificationStrategy, 1, wxALL, 5);
    mainSizer->Add(strategySizer, 0, wxEXPAND);
 
    // Type lists section header with info button
    wxBoxSizer *listsHeaderSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Reload bitmaps for this button
    wxBitmap infoNormal4(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover4(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed4(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled4(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    wxBitmapButton *infoBtn4 = new wxBitmapButton(panel, wxID_ANY, infoNormal4, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn4->SetBitmapHover(infoHover4);
    infoBtn4->SetBitmapPressed(infoPressed4);
    infoBtn4->SetBitmapDisabled(infoDisabled4);
    infoBtn4->SetToolTip("Click for detailed information");
    infoBtn4->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "NODE TYPE LISTS\n"
                            "===========================================================\n\n"
                            "These lists define the SPECIFIC NODE TYPES recognized in each\n"
                            "category. Used for element-name and attribute-based classification.\n\n"
                            "HOW THEY WORK:\n"
                            "When the parser encounters a node, it checks if the node's name\n"
                            "(element or attribute value) appears in one of these lists to\n"
                            "determine its category.\n\n"
                            "FOUR CATEGORIES:\n\n"
                            "1. CONTROL TYPES (Required)\n"
                            "   Flow control nodes that manage child execution\n"
                            "   Common examples:\n"
                            "     - Sequence, Selector, Fallback\n"
                            "     - Parallel, ParallelSequence\n"
                            "     - ReactiveSequence, ReactiveFallback\n"
                            "     - IfThenElse, Switch, WhileDoElse\n"
                            "   These nodes MUST have at least one child\n\n"
                            "2. DECORATOR TYPES (Required)\n"
                            "   Wrapper nodes that modify a single child's behavior\n"
                            "   Common examples:\n"
                            "     - Inverter, ForceSuccess, ForceFailure\n"
                            "     - Retry, Repeat, RepeatUntilSuccess\n"
                            "     - Timeout, Delay\n"
                            "     - KeepRunningUntilFailure\n"
                            "   These nodes MUST have exactly one child\n\n"
                            "3. ACTION TYPES (Optional)\n"
                            "   Leaf nodes that perform tasks\n"
                            "   Common examples:\n"
                            "     - MoveToTarget, Attack, Wait\n"
                            "     - PlayAnimation, SetBlackboard\n"
                            "     - Custom action nodes\n"
                            "   Leave empty to allow any non-classified leaf as Action\n\n"
                            "4. CONDITION TYPES (Optional)\n"
                            "   Leaf nodes that check state (instant, no RUNNING)\n"
                            "   Common examples:\n"
                            "     - IsHealthLow, IsEnemyInRange\n"
                            "     - CheckBlackboard, IsBoolTrue\n"
                            "     - Custom condition nodes\n"
                            "   Leave empty to allow any non-classified leaf as Condition\n\n"
                            "ADDING ENTRIES:\n"
                            "  1. Click '+' button\n"
                            "  2. Enter the exact node type name\n"
                            "  3. Case-sensitive (usually)\n\n"
                            "EXAMPLE CLASSIFICATION:\n"
                            "  Lists: Control=[Sequence, Selector], Decorator=[Inverter]\n"
                            "  XML: <Sequence> -> Control (in list)\n"
                            "  XML: <Inverter> -> Decorator (in list)\n"
                            "  XML: <CustomAction> -> Action (not in any list)\n\n"
                            "RECOMMENDATION:\n"
                            "Always define Control and Decorator types. Leave Action/Condition\n"
                            "empty for maximum flexibility unless you need strict validation.";
        HelpDialog dlg(this, "Node Type Lists - Help", helpText);
        dlg.ShowModal();
    });
    listsHeaderSizer->Add(infoBtn4, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
    wxStaticText *listsLabel = new wxStaticText(panel, wxID_ANY, "Node Type Recognition Lists:");
    wxFont font = listsLabel->GetFont();
    font.SetWeight(wxFONTWEIGHT_BOLD);
    listsLabel->SetFont(font);
    listsHeaderSizer->Add(listsLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
    mainSizer->Add(listsHeaderSizer, 0, wxEXPAND);
 
    // Type lists in a grid
    wxBoxSizer *listsGrid = new wxBoxSizer(wxHORIZONTAL);
 
    // Control types
    wxStaticBoxSizer *controlBox = new wxStaticBoxSizer(wxVERTICAL, panel, "Control Types");
    m_controlTypesList = new wxListBox(controlBox->GetStaticBox(), wxID_ANY);
    controlBox->Add(m_controlTypesList, 1, wxEXPAND | wxALL, 5);
    wxBoxSizer *controlBtnSizer = new wxBoxSizer(wxHORIZONTAL);
    m_addControlTypeBtn = new wxButton(controlBox->GetStaticBox(), ID_ADD_CONTROL_TYPE, "+");
    m_removeControlTypeBtn = new wxButton(controlBox->GetStaticBox(), ID_REMOVE_CONTROL_TYPE, "-");
    controlBtnSizer->Add(m_addControlTypeBtn, 1, wxALL, 2);
    controlBtnSizer->Add(m_removeControlTypeBtn, 1, wxALL, 2);
    controlBox->Add(controlBtnSizer, 0, wxEXPAND);
    listsGrid->Add(controlBox, 1, wxEXPAND | wxALL, 5);
 
    // Decorator types
    wxStaticBoxSizer *decoratorBox = new wxStaticBoxSizer(wxVERTICAL, panel, "Decorator Types");
    m_decoratorTypesList = new wxListBox(decoratorBox->GetStaticBox(), wxID_ANY);
    decoratorBox->Add(m_decoratorTypesList, 1, wxEXPAND | wxALL, 5);
    wxBoxSizer *decoratorBtnSizer = new wxBoxSizer(wxHORIZONTAL);
    m_addDecoratorTypeBtn = new wxButton(decoratorBox->GetStaticBox(), ID_ADD_DECORATOR_TYPE, "+");
    m_removeDecoratorTypeBtn = new wxButton(decoratorBox->GetStaticBox(), ID_REMOVE_DECORATOR_TYPE, "-");
    decoratorBtnSizer->Add(m_addDecoratorTypeBtn, 1, wxALL, 2);
    decoratorBtnSizer->Add(m_removeDecoratorTypeBtn, 1, wxALL, 2);
    decoratorBox->Add(decoratorBtnSizer, 0, wxEXPAND);
    listsGrid->Add(decoratorBox, 1, wxEXPAND | wxALL, 5);
 
    mainSizer->Add(listsGrid, 1, wxEXPAND);
 
    // Second row: Action and Condition types
    wxBoxSizer *listsGrid2 = new wxBoxSizer(wxHORIZONTAL);
 
    // Action types
    wxStaticBoxSizer *actionBox = new wxStaticBoxSizer(wxVERTICAL, panel, "Action Types (optional)");
    m_actionTypesList = new wxListBox(actionBox->GetStaticBox(), wxID_ANY);
    actionBox->Add(m_actionTypesList, 1, wxEXPAND | wxALL, 5);
    wxBoxSizer *actionBtnSizer = new wxBoxSizer(wxHORIZONTAL);
    m_addActionTypeBtn = new wxButton(actionBox->GetStaticBox(), ID_ADD_ACTION_TYPE, "+");
    m_removeActionTypeBtn = new wxButton(actionBox->GetStaticBox(), ID_REMOVE_ACTION_TYPE, "-");
    actionBtnSizer->Add(m_addActionTypeBtn, 1, wxALL, 2);
    actionBtnSizer->Add(m_removeActionTypeBtn, 1, wxALL, 2);
    actionBox->Add(actionBtnSizer, 0, wxEXPAND);
    listsGrid2->Add(actionBox, 1, wxEXPAND | wxALL, 5);
 
    // Condition types
    wxStaticBoxSizer *conditionBox = new wxStaticBoxSizer(wxVERTICAL, panel, "Condition Types (optional)");
    m_conditionTypesList = new wxListBox(conditionBox->GetStaticBox(), wxID_ANY);
    conditionBox->Add(m_conditionTypesList, 1, wxEXPAND | wxALL, 5);
    wxBoxSizer *conditionBtnSizer = new wxBoxSizer(wxHORIZONTAL);
    m_addConditionTypeBtn = new wxButton(conditionBox->GetStaticBox(), ID_ADD_CONDITION_TYPE, "+");
    m_removeConditionTypeBtn = new wxButton(conditionBox->GetStaticBox(), ID_REMOVE_CONDITION_TYPE, "-");
    conditionBtnSizer->Add(m_addConditionTypeBtn, 1, wxALL, 2);
    conditionBtnSizer->Add(m_removeConditionTypeBtn, 1, wxALL, 2);
    conditionBox->Add(conditionBtnSizer, 0, wxEXPAND);
    listsGrid2->Add(conditionBox, 1, wxEXPAND | wxALL, 5);
 
    mainSizer->Add(listsGrid2, 1, wxEXPAND);
 
    // Unknown behavior
    wxBoxSizer *unknownSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Reload bitmaps for this button
    wxBitmap infoNormal2(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover2(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed2(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled2(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    wxBitmapButton *infoBtn2 = new wxBitmapButton(panel, wxID_ANY, infoNormal2, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn2->SetBitmapHover(infoHover2);
    infoBtn2->SetBitmapPressed(infoPressed2);
    infoBtn2->SetBitmapDisabled(infoDisabled2);
    infoBtn2->SetToolTip("Click for detailed information");
    infoBtn2->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "UNKNOWN TYPE BEHAVIOR\n"
                            "===========================================================\n\n"
                            "Determines what happens when the parser encounters a node type\n"
                            "that is NOT in your defined type lists (Control, Decorator, etc.).\n\n"
                            "THREE OPTIONS:\n\n"
                            "1. ERROR (Strict - Recommended for Development)\n"
                            "   - Parser STOPS and reports an error\n"
                            "   - File loading FAILS\n"
                            "   - Ensures all node types are explicitly defined\n"
                            "   Example: <UnknownNode/> causes parsing to fail\n"
                            "   Use when:\n"
                            "     - Developing new trees - catch typos early\n"
                            "     - Want strict validation\n"
                            "     - Need to ensure only known types are used\n\n"
                            "2. WARNING (Permissive)\n"
                            "   - Parser CONTINUES but logs a warning\n"
                            "   - File loads successfully\n"
                            "   - Unknown node is treated as Generic Node\n"
                            "   Example: <UnknownNode/> becomes a generic node + warning\n"
                            "   Use when:\n"
                            "     - Working with mixed/evolving formats\n"
                            "     - Want to see what's unrecognized but still load\n"
                            "     - Debugging format compatibility\n\n"
                            "3. GENERIC NODE (Silent Fallback)\n"
                            "   - Parser treats unknown types as generic nodes\n"
                            "   - NO warning or error\n"
                            "   - Maximum compatibility\n"
                            "   Example: <UnknownNode/> silently becomes generic node\n"
                            "   Use when:\n"
                            "     - Working with highly variable XML formats\n"
                            "     - Want maximum flexibility\n"
                            "     - Already validated your trees externally\n\n"
                            "RECOMMENDATION:\n"
                            "Use ERROR during development to catch typos and undefined types.\n"
                            "Use WARNING in production if you need to support evolving formats.";
        HelpDialog dlg(this, "Unknown Type Behavior - Help", helpText);
        dlg.ShowModal();
    });
    unknownSizer->Add(infoBtn2, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
    unknownSizer->Add(new wxStaticText(panel, wxID_ANY, "Unknown Type Behavior:"), 0, wxALIGN_CENTER_VERTICAL | wxALL,
                      5);
    wxArrayString unknownChoices;
    unknownChoices.Add("Error");
    unknownChoices.Add("Warning");
    unknownChoices.Add("Generic Node");
    m_unknownBehavior = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, unknownChoices);
    m_unknownBehavior->SetSelection(0);
    unknownSizer->Add(m_unknownBehavior, 1, wxALL, 5);
    mainSizer->Add(unknownSizer, 0, wxEXPAND);
 
    // Type attribute name
    wxBoxSizer *typeAttrSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Reload bitmaps for this button
    wxBitmap infoNormal3(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover3(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed3(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled3(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    wxBitmapButton *infoBtn3 = new wxBitmapButton(panel, wxID_ANY, infoNormal3, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn3->SetBitmapHover(infoHover3);
    infoBtn3->SetBitmapPressed(infoPressed3);
    infoBtn3->SetBitmapDisabled(infoDisabled3);
    infoBtn3->SetToolTip("Click for detailed information");
    infoBtn3->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "TYPE ATTRIBUTE NAME\n"
                            "===========================================================\n\n"
                            "The XML attribute name used for by-attribute node classification.\n"
                            "Only relevant when using 'By Attribute' or 'Hybrid' strategy.\n\n"
                            "WHAT IS IT?\n"
                            "When using attribute-based classification, this attribute specifies\n"
                            "the node category (Control, Action, Condition, Decorator).\n\n"
                            "COMMON VALUES:\n"
                            "  - 'type' - Most common standard\n"
                            "  - 'nodeType' - Explicit variant\n"
                            "  - 'category' - Alternative naming\n\n"
                            "HOW IT WORKS:\n\n"
                            "BY ATTRIBUTE STRATEGY:\n"
                            "  <Node type=\"Sequence\">  <!-- 'type' is the attribute -->\n"
                            "    <Node type=\"Action\" name=\"Move\"/>\n"
                            "    <Node type=\"Condition\" name=\"Check\"/>\n"
                            "  </Node>\n"
                            "  The parser reads the 'type' attribute to determine:\n"
                            "    - 'Sequence' -> Control node (from Control Types list)\n"
                            "    - 'Action' -> Action node (from Action Types list)\n"
                            "    - 'Condition' -> Condition node (from Condition Types list)\n\n"
                            "HYBRID STRATEGY:\n"
                            "  <Sequence>  <!-- Element name = Control -->\n"
                            "    <Node type=\"Action\" name=\"Custom\"/>  <!-- Attribute -->\n"
                            "    <Condition name=\"Check\"/>  <!-- Element name -->\n"
                            "  </Sequence>\n"
                            "  Parser checks element name first, falls back to attribute.\n\n"
                            "BY ELEMENT NAME STRATEGY:\n"
                            "  This setting is IGNORED (not used)\n\n"
                            "CLASSIFICATION FLOW:\n"
                            "  1. Read node's type attribute value\n"
                            "  2. Check if value is in Control Types -> Control node\n"
                            "  3. Check if value is in Decorator Types -> Decorator node\n"
                            "  4. Check if value is in Action Types -> Action node\n"
                            "  5. Check if value is in Condition Types -> Condition node\n"
                            "  6. Not found -> Apply Unknown Type Behavior\n\n"
                            "RECOMMENDATION:\n"
                            "Use 'type' for standard compatibility. Leave empty if using\n"
                            "'By Element Name' strategy exclusively.";
        HelpDialog dlg(this, "Type Attribute Name - Help", helpText);
        dlg.ShowModal();
    });
    typeAttrSizer->Add(infoBtn3, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
    typeAttrSizer->Add(new wxStaticText(panel, wxID_ANY, "Type Attribute Name:"), 0, wxALIGN_CENTER_VERTICAL | wxALL,
                       5);
    m_typeAttrName = new wxTextCtrl(panel, wxID_ANY);
    m_typeAttrName->SetToolTip("Attribute name used for by-attribute classification");
    m_typeAttrName->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    typeAttrSizer->Add(m_typeAttrName, 1, wxALL, 5);
    mainSizer->Add(typeAttrSizer, 0, wxEXPAND);
 
    panel->SetSizer(mainSizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::CreateBlackboardTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Load info button bitmaps
    wxBitmap infoNormal(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    // Basic blackboard configuration
    wxGridBagSizer *basicSizer = new wxGridBagSizer(5, 5);
    int row = 0;
 
    // Blackboard element
    wxBoxSizer *labelSizer1 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn1 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn1->SetBitmapHover(infoHover);
    infoBtn1->SetBitmapPressed(infoPressed);
    infoBtn1->SetBitmapDisabled(infoDisabled);
    infoBtn1->SetToolTip("Click for detailed information");
    infoBtn1->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "BLACKBOARD ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents a blackboard definition - a\n"
                            "shared data storage that behavior trees use to store and access variables.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'BlackboardModel' - BehaviorTree.CPP standard\n"
                            "  - 'Blackboard' - Simplified variant\n"
                            "  - 'Variables' - Alternative naming\n\n"
                            "WHAT IS A BLACKBOARD?\n"
                            "A blackboard is a KEY-VALUE data store that:\n"
                            "  - Stores variables shared across the behavior tree\n"
                            "  - Provides data for condition checks and actions\n"
                            "  - Can be defined once and used by multiple trees\n"
                            "  - Supports typed data (int, float, string, bool, etc.)\n\n"
                            "EXAMPLE:\n"
                            "  <root>\n"
                            "    <BlackboardModel ID=\"PlayerBlackboard\">\n"
                            "      <Entry key=\"health\" type=\"int\" value=\"100\"/>\n"
                            "      <Entry key=\"target\" type=\"string\"/>\n"
                            "      <Entry key=\"isAggressive\" type=\"bool\" value=\"false\"/>\n"
                            "    </BlackboardModel>\n\n"
                            "    <BehaviorTree ID=\"MainAI\" blackboard=\"PlayerBlackboard\">\n"
                            "      <!-- Tree uses the blackboard -->\n"
                            "    </BehaviorTree>\n"
                            "  </root>\n\n"
                            "WHY USE BLACKBOARDS?\n"
                            "  - Share data between different parts of the tree\n"
                            "  - Parameterize behavior trees for reusability\n"
                            "  - Type-safe data access\n"
                            "  - Runtime variable inspection and debugging";
        HelpDialog dlg(this, "Blackboard Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer1->Add(infoBtn1, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer1->Add(new wxStaticText(panel, wxID_ANY, "Blackboard Element:"), 0, wxALIGN_CENTER_VERTICAL);
    basicSizer->Add(labelSizer1, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_blackboardElement = new wxTextCtrl(panel, wxID_ANY);
    m_blackboardElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    basicSizer->Add(m_blackboardElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Blackboard ID attribute
    wxBoxSizer *labelSizer2 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn2 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn2->SetBitmapHover(infoHover);
    infoBtn2->SetBitmapPressed(infoPressed);
    infoBtn2->SetBitmapDisabled(infoDisabled);
    infoBtn2->SetToolTip("Click for detailed information");
    infoBtn2->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "BLACKBOARD ID ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that contains the unique identifier for\n"
                            "each blackboard definition.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'ID' - Standard naming (most common)\n"
                            "  - 'name' - Alternative\n"
                            "  - 'id' - Lowercase variant\n\n"
                            "WHY IS IT NEEDED?\n"
                            "The ID allows:\n"
                            "  - Multiple blackboard definitions in one file\n"
                            "  - Behavior trees to reference specific blackboards\n"
                            "  - Blackboard inheritance (one extends another)\n"
                            "  - Runtime blackboard lookup by name\n\n"
                            "EXAMPLE:\n"
                            "  <BlackboardModel ID=\"BaseAI\">\n"
                            "    <Entry key=\"speed\" type=\"float\" value=\"5.0\"/>\n"
                            "  </BlackboardModel>\n\n"
                            "  <BlackboardModel ID=\"EnemyAI\" parent=\"BaseAI\">\n"
                            "    <Entry key=\"health\" type=\"int\" value=\"100\"/>\n"
                            "    <!-- Inherits 'speed' from BaseAI -->\n"
                            "  </BlackboardModel>\n\n"
                            "  <BehaviorTree ID=\"Enemy\" blackboard=\"EnemyAI\">\n"
                            "                              ^^^^^^^^^^^^^^^^^^^\n"
                            "                              References blackboard by ID\n"
                            "  </BehaviorTree>\n\n"
                            "RECOMMENDATION:\n"
                            "Use 'ID' for consistency with BehaviorTree.CPP standard.";
        HelpDialog dlg(this, "Blackboard ID Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer2->Add(infoBtn2, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer2->Add(new wxStaticText(panel, wxID_ANY, "Blackboard ID Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    basicSizer->Add(labelSizer2, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_blackboardIdAttr = new wxTextCtrl(panel, wxID_ANY);
    m_blackboardIdAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    basicSizer->Add(m_blackboardIdAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Parent attribute
    wxBoxSizer *labelSizer3 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn3 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn3->SetBitmapHover(infoHover);
    infoBtn3->SetBitmapPressed(infoPressed);
    infoBtn3->SetBitmapDisabled(infoDisabled);
    infoBtn3->SetToolTip("Click for detailed information");
    infoBtn3->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "PARENT/INHERITANCE ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that specifies a parent blackboard from\n"
                            "which the current blackboard inherits entries.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'parent' - Most common\n"
                            "  - 'extends' - Object-oriented terminology\n"
                            "  - 'inherits' - Explicit naming\n"
                            "  - 'base' - Alternative\n\n"
                            "HOW INHERITANCE WORKS:\n"
                            "A child blackboard:\n"
                            "  - Inherits ALL entries from its parent\n"
                            "  - Can add NEW entries not in the parent\n"
                            "  - Can OVERRIDE parent entries with different defaults\n"
                            "  - Cannot remove parent entries\n\n"
                            "EXAMPLE:\n"
                            "  <BlackboardModel ID=\"BaseCharacter\">\n"
                            "    <Entry key=\"health\" type=\"int\" value=\"100\"/>\n"
                            "    <Entry key=\"speed\" type=\"float\" value=\"5.0\"/>\n"
                            "  </BlackboardModel>\n\n"
                            "  <BlackboardModel ID=\"Player\" parent=\"BaseCharacter\">\n"
                            "    <Entry key=\"mana\" type=\"int\" value=\"50\"/>\n"
                            "    <Entry key=\"speed\" type=\"float\" value=\"7.0\"/>\n"
                            "    <!-- Inherits: health=100 (from parent) -->\n"
                            "    <!-- Overrides: speed=7.0 (not 5.0) -->\n"
                            "    <!-- Adds: mana=50 (new entry) -->\n"
                            "  </BlackboardModel>\n\n"
                            "BENEFITS:\n"
                            "  - Reduce duplication in blackboard definitions\n"
                            "  - Create base templates for common variables\n"
                            "  - Organize related blackboards hierarchically";
        HelpDialog dlg(this, "Parent/Inheritance Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer3->Add(infoBtn3, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer3->Add(new wxStaticText(panel, wxID_ANY, "Parent/Inheritance Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    basicSizer->Add(labelSizer3, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_blackboardParentAttr = new wxTextCtrl(panel, wxID_ANY);
    m_blackboardParentAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    basicSizer->Add(m_blackboardParentAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Entry element
    wxBoxSizer *labelSizer4 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn4 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn4->SetBitmapHover(infoHover);
    infoBtn4->SetBitmapPressed(infoPressed);
    infoBtn4->SetBitmapDisabled(infoDisabled);
    infoBtn4->SetToolTip("Click for detailed information");
    infoBtn4->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ENTRY ELEMENT\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML element name that represents a single variable/entry\n"
                            "within a blackboard definition.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'Entry' - BehaviorTree.CPP standard\n"
                            "  - 'Variable' - Descriptive alternative\n"
                            "  - 'Field' - Object-oriented terminology\n"
                            "  - 'Property' - Another variant\n\n"
                            "WHAT IS AN ENTRY?\n"
                            "Each entry represents ONE variable in the blackboard:\n"
                            "  - Has a KEY (variable name)\n"
                            "  - Has a TYPE (int, float, string, bool, etc.)\n"
                            "  - May have a DEFAULT VALUE\n"
                            "  - Can be read/written by nodes during execution\n\n"
                            "EXAMPLE:\n"
                            "  <BlackboardModel ID=\"GameAI\">\n"
                            "    <Entry key=\"playerHealth\" type=\"int\" value=\"100\"/>\n"
                            "    <Entry key=\"targetPosition\" type=\"Vector3\"/>\n"
                            "    <Entry key=\"isAlerted\" type=\"bool\" value=\"false\"/>\n"
                            "    <Entry key=\"patrolSpeed\" type=\"float\" value=\"2.5\"/>\n"
                            "    <Entry key=\"weaponName\" type=\"string\" value=\"Sword\"/>\n"
                            "  </BlackboardModel>\n\n"
                            "USAGE IN BEHAVIOR TREE:\n"
                            "  <Condition name=\"CheckHealth\">\n"
                            "    <input key=\"health\" blackboard_key=\"playerHealth\"/>\n"
                            "  </Condition>\n\n"
                            "  <Action name=\"SetAlert\">\n"
                            "    <output key=\"isAlerted\" blackboard_key=\"isAlerted\" value=\"true\"/>\n"
                            "  </Action>";
        HelpDialog dlg(this, "Entry Element - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer4->Add(infoBtn4, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer4->Add(new wxStaticText(panel, wxID_ANY, "Entry Element:"), 0, wxALIGN_CENTER_VERTICAL);
    basicSizer->Add(labelSizer4, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_entryElement = new wxTextCtrl(panel, wxID_ANY);
    m_entryElement->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    basicSizer->Add(m_entryElement, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Entry key attribute
    wxBoxSizer *labelSizer5 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn5 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn5->SetBitmapHover(infoHover);
    infoBtn5->SetBitmapPressed(infoPressed);
    infoBtn5->SetBitmapDisabled(infoDisabled);
    infoBtn5->SetToolTip("Click for detailed information");
    infoBtn5->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ENTRY KEY ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that contains the KEY (variable name)\n"
                            "for a blackboard entry.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'key' - BehaviorTree.CPP standard\n"
                            "  - 'name' - Alternative common usage\n"
                            "  - 'id' - Some implementations\n\n"
                            "WHAT IS A KEY?\n"
                            "The key is the UNIQUE IDENTIFIER for a variable within a blackboard:\n"
                            "  - Acts as the variable name\n"
                            "  - Used to read/write the value at runtime\n"
                            "  - Must be unique within the blackboard\n"
                            "  - Case-sensitive (usually)\n\n"
                            "EXAMPLE:\n"
                            "  <Entry key=\"playerHealth\" type=\"int\" value=\"100\"/>\n"
                            "         ^^^^^^^^^^^^^^^^^^^\n"
                            "         This is the key - the variable name\n\n"
                            "  <!-- In behavior tree nodes: -->\n"
                            "  <Condition name=\"IsHealthLow\">\n"
                            "    <input key=\"health\" blackboard_key=\"playerHealth\"/>\n"
                            "                                    ^^^^^^^^^^^^^^^^^\n"
                            "                                    References by key\n"
                            "  </Condition>\n\n"
                            "NAMING CONVENTIONS:\n"
                            "  - camelCase: playerHealth, maxSpeed, isActive\n"
                            "  - snake_case: player_health, max_speed, is_active\n"
                            "  - PascalCase: PlayerHealth, MaxSpeed, IsActive\n\n"
                            "RECOMMENDATION:\n"
                            "Use descriptive, consistent names following your project's\n"
                            "naming convention. Common standard is camelCase.";
        HelpDialog dlg(this, "Entry Key Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer5->Add(infoBtn5, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer5->Add(new wxStaticText(panel, wxID_ANY, "Entry Key Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    basicSizer->Add(labelSizer5, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_entryKeyAttr = new wxTextCtrl(panel, wxID_ANY);
    m_entryKeyAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    basicSizer->Add(m_entryKeyAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Entry type attribute
    wxBoxSizer *labelSizer6 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn6 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn6->SetBitmapHover(infoHover);
    infoBtn6->SetBitmapPressed(infoPressed);
    infoBtn6->SetBitmapDisabled(infoDisabled);
    infoBtn6->SetToolTip("Click for detailed information");
    infoBtn6->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ENTRY TYPE ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that specifies the DATA TYPE for a\n"
                            "blackboard entry (int, float, string, bool, etc.).\n\n"
                            "COMMON VALUES:\n"
                            "  - 'type' - Most common standard\n"
                            "  - 'dataType' - Explicit variant\n"
                            "  - 'valueType' - Alternative\n\n"
                            "SUPPORTED TYPES (typical):\n"
                            "  PRIMITIVES:\n"
                            "    - 'int' / 'integer' - Whole numbers (e.g., 42, -10)\n"
                            "    - 'float' / 'double' - Decimals (e.g., 3.14, -2.5)\n"
                            "    - 'bool' / 'boolean' - true/false\n"
                            "    - 'string' - Text (e.g., \"Hello\", \"weapon_1\")\n\n"
                            "  ADVANCED (depends on implementation):\n"
                            "    - 'Vector2' / 'Vector3' - Position/direction\n"
                            "    - 'Pose' / 'Pose2D' - Position + rotation\n"
                            "    - 'array' - List of values\n"
                            "    - 'object' - Complex custom types\n\n"
                            "EXAMPLE:\n"
                            "  <Entry key=\"health\" type=\"int\" value=\"100\"/>\n"
                            "  <Entry key=\"speed\" type=\"float\" value=\"5.5\"/>\n"
                            "  <Entry key=\"isAlive\" type=\"bool\" value=\"true\"/>\n"
                            "  <Entry key=\"name\" type=\"string\" value=\"Player\"/>\n"
                            "  <Entry key=\"position\" type=\"Vector3\"/>\n\n"
                            "WHY TYPES MATTER:\n"
                            "  - Type safety: prevent wrong value assignments\n"
                            "  - Runtime validation\n"
                            "  - Editor support (proper UI widgets)\n"
                            "  - Performance optimization";
        HelpDialog dlg(this, "Entry Type Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer6->Add(infoBtn6, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer6->Add(new wxStaticText(panel, wxID_ANY, "Entry Type Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    basicSizer->Add(labelSizer6, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_entryTypeAttr = new wxTextCtrl(panel, wxID_ANY);
    m_entryTypeAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    basicSizer->Add(m_entryTypeAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Entry value attribute
    wxBoxSizer *labelSizer7 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn7 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn7->SetBitmapHover(infoHover);
    infoBtn7->SetBitmapPressed(infoPressed);
    infoBtn7->SetBitmapDisabled(infoDisabled);
    infoBtn7->SetToolTip("Click for detailed information");
    infoBtn7->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ENTRY VALUE ATTRIBUTE\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "The XML attribute name that contains the DEFAULT VALUE for a\n"
                            "blackboard entry.\n\n"
                            "COMMON VALUES:\n"
                            "  - 'value' - Most common\n"
                            "  - 'default' - Explicit naming\n"
                            "  - 'defaultValue' - Verbose variant\n\n"
                            "WHAT IS A DEFAULT VALUE?\n"
                            "The default value is the INITIAL value assigned when:\n"
                            "  - A blackboard is first created/instantiated\n"
                            "  - A behavior tree starts executing\n"
                            "  - The blackboard is reset\n\n"
                            "OPTIONAL vs REQUIRED:\n"
                            "  - Some entries HAVE defaults (value specified)\n"
                            "  - Some entries DON'T (must be set at runtime)\n\n"
                            "EXAMPLE:\n"
                            "  <Entry key=\"health\" type=\"int\" value=\"100\"/>\n"
                            "                                   ^^^^^^^^^^^^^\n"
                            "                                   Starts with 100\n\n"
                            "  <Entry key=\"currentTarget\" type=\"string\"/>\n"
                            "                                   No default - must be set\n\n"
                            "  <Entry key=\"isAlerted\" type=\"bool\" value=\"false\"/>\n"
                            "                                      ^^^^^^^^^^^^^^^^\n"
                            "                                      Starts as false\n\n"
                            "TYPE-SPECIFIC FORMATS:\n"
                            "  - int: \"42\", \"-10\", \"0\"\n"
                            "  - float: \"3.14\", \"-2.5\", \"0.0\"\n"
                            "  - bool: \"true\", \"false\" (case-insensitive)\n"
                            "  - string: \"PlayerName\", \"idle_animation\"\n"
                            "  - Vector3: \"1.0,2.0,3.0\" (comma-separated)\n\n"
                            "RECOMMENDATION:\n"
                            "Provide sensible defaults when possible to make trees\n"
                            "more self-contained and easier to test.";
        HelpDialog dlg(this, "Entry Value Attribute - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer7->Add(infoBtn7, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer7->Add(new wxStaticText(panel, wxID_ANY, "Entry Value Attribute:"), 0, wxALIGN_CENTER_VERTICAL);
    basicSizer->Add(labelSizer7, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_entryValueAttr = new wxTextCtrl(panel, wxID_ANY);
    m_entryValueAttr->Bind(wxEVT_TEXT, &ParserConfigDialog::OnFieldChanged, this);
    basicSizer->Add(m_entryValueAttr, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    basicSizer->AddGrowableCol(1);
    mainSizer->Add(basicSizer, 0, wxEXPAND | wxALL, 5);
 
    // Type mappings
    wxStaticBoxSizer *mappingsBox = new wxStaticBoxSizer(wxVERTICAL, panel, "Data Type Mappings");
    m_typeMappingsGrid = new wxGrid(mappingsBox->GetStaticBox(), wxID_ANY);
    m_typeMappingsGrid->CreateGrid(0, 2);
    m_typeMappingsGrid->SetColLabelValue(0, "XML Type");
    m_typeMappingsGrid->SetColLabelValue(1, "Internal Type");
 
    // Set wider column widths to make text fully visible
    m_typeMappingsGrid->SetColSize(0, 250); // XML Type column width
    m_typeMappingsGrid->SetColSize(1, 250); // Internal Type column width
 
    m_typeMappingsGrid->SetMinSize(wxSize(-1, 150));
    mappingsBox->Add(m_typeMappingsGrid, 1, wxEXPAND | wxALL, 5);
 
    wxBoxSizer *mappingBtnSizer = new wxBoxSizer(wxHORIZONTAL);
    m_addMappingBtn = new wxButton(mappingsBox->GetStaticBox(), ID_ADD_MAPPING, "Add Mapping");
    m_removeMappingBtn = new wxButton(mappingsBox->GetStaticBox(), ID_REMOVE_MAPPING, "Remove Selected");
    mappingBtnSizer->Add(m_addMappingBtn, 0, wxALL, 2);
    mappingBtnSizer->Add(m_removeMappingBtn, 0, wxALL, 2);
    mappingsBox->Add(mappingBtnSizer, 0);
 
    mainSizer->Add(mappingsBox, 1, wxEXPAND | wxALL, 5);
 
    // Allow undefined keys
    m_allowUndefinedKeys = new wxCheckBox(panel, wxID_ANY, "Allow Undefined Blackboard Keys");
    mainSizer->Add(m_allowUndefinedKeys, 0, wxALL, 5);
 
    panel->SetSizer(mainSizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::CreateAdvancedTab(wxNotebook *notebook) {
    wxPanel *panel = new wxPanel(notebook);
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Load info button bitmaps
    wxBitmap infoNormal(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
 
    // Options in grid
    wxGridBagSizer *sizer = new wxGridBagSizer(5, 5);
    int row = 0;
 
    // Progress reporting
    wxBoxSizer *labelSizer1 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmapButton *infoBtn1 = new wxBitmapButton(panel, wxID_ANY, infoNormal, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn1->SetBitmapHover(infoHover);
    infoBtn1->SetBitmapPressed(infoPressed);
    infoBtn1->SetBitmapDisabled(infoDisabled);
    infoBtn1->SetToolTip("Click for detailed information");
    infoBtn1->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "ENABLE PROGRESS REPORTING\n"
                            "===========================================================\n\n"
                            "WHAT IS IT?\n"
                            "Controls whether the parser reports progress updates during XML\n"
                            "parsing operations, especially useful for large files.\n\n"
                            "ENABLED:\n"
                            "  - Parser emits progress callbacks during parsing\n"
                            "  - UI can show loading bars or progress indicators\n"
                            "  - Helps prevent \"app not responding\" appearance\n"
                            "  - Useful for files > 1000 nodes\n"
                            "  - Small performance overhead (~2-5%)\n\n"
                            "DISABLED:\n"
                            "  - No progress updates\n"
                            "  - Slightly faster parsing\n"
                            "  - Simpler implementation\n"
                            "  - Best for small/medium files\n\n"
                            "USE CASES:\n"
                            "Enable when:\n"
                            "  - Loading very large behavior tree files\n"
                            "  - Need to show user feedback during loading\n"
                            "  - Parsing operations take > 1 second\n\n"
                            "Disable when:\n"
                            "  - Working with small files (< 100 nodes)\n"
                            "  - Maximum parsing speed is priority\n"
                            "  - No UI for displaying progress\n\n"
                            "RECOMMENDATION:\n"
                            "Enable for production applications to improve user experience\n"
                            "when loading large behavior tree files.";
        HelpDialog dlg(this, "Progress Reporting - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer1->Add(infoBtn1, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_enableProgressReporting = new wxCheckBox(panel, wxID_ANY, "Enable Progress Reporting");
    m_enableProgressReporting->SetToolTip("Report parsing progress for large files");
    labelSizer1->Add(m_enableProgressReporting, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer1, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // Detailed errors
    wxBoxSizer *labelSizer2 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal2(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover2(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed2(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled2(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn2 = new wxBitmapButton(panel, wxID_ANY, infoNormal2, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn2->SetBitmapHover(infoHover2);
    infoBtn2->SetBitmapPressed(infoPressed2);
    infoBtn2->SetBitmapDisabled(infoDisabled2);
    infoBtn2->SetToolTip("Click for detailed information");
    infoBtn2->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "DETAILED ERROR MESSAGES\n"
                            "===========================================================\n\n"
                            "Controls the verbosity of error messages when parsing fails.\n\n"
                            "ENABLED (Recommended for Development):\n"
                            "  - Full error descriptions with context\n"
                            "  - Shows exact line and column numbers\n"
                            "  - Includes surrounding XML context\n"
                            "  - Lists all violated validation rules\n"
                            "  - Suggests possible fixes\n\n"
                            "Example detailed error:\n"
                            "  ERROR at line 42, column 15:\n"
                            "  Unknown element 'Sequenc' found.\n"
                            "  Context: <Sequenc name=\"Patrol\">\n"
                            "  Did you mean: 'Sequence'?\n"
                            "  Valid elements: Sequence, Selector, Parallel\n\n"
                            "DISABLED (Production):\n"
                            "  - Brief error messages\n"
                            "  - Just error type and location\n"
                            "  - Less information leakage\n"
                            "  - Slightly faster\n\n"
                            "Example simple error:\n"
                            "  Parse error at line 42: Unknown element\n\n"
                            "USE CASES:\n"
                            "Enable when:\n"
                            "  - Developing behavior trees\n"
                            "  - Debugging XML format issues\n"
                            "  - Users need helpful error messages\n\n"
                            "Disable when:\n"
                            "  - Production/release builds\n"
                            "  - Security concerns about information disclosure\n"
                            "  - Minimal error output desired\n\n"
                            "RECOMMENDATION:\n"
                            "Keep ENABLED during development. Consider disabling for\n"
                            "production if error details are security-sensitive.";
        HelpDialog dlg(this, "Detailed Error Messages - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer2->Add(infoBtn2, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_detailedErrors = new wxCheckBox(panel, wxID_ANY, "Detailed Error Messages");
    m_detailedErrors->SetToolTip("Include detailed context in error messages");
    labelSizer2->Add(m_detailedErrors, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer2, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // Track line/column
    wxBoxSizer *labelSizer3 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal3(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover3(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed3(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled3(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn3 = new wxBitmapButton(panel, wxID_ANY, infoNormal3, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn3->SetBitmapHover(infoHover3);
    infoBtn3->SetBitmapPressed(infoPressed3);
    infoBtn3->SetBitmapDisabled(infoDisabled3);
    infoBtn3->SetToolTip("Click for detailed information");
    infoBtn3->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "TRACK LINE/COLUMN NUMBERS\n"
                            "===========================================================\n\n"
                            "Controls whether the parser maintains line and column position\n"
                            "information for every parsed element.\n\n"
                            "ENABLED:\n"
                            "  - Every node tracks its source location (line, column)\n"
                            "  - Error messages show EXACT locations\n"
                            "  - Enables \"jump to source\" in editors\n"
                            "  - Useful for debugging and validation\n"
                            "  - Small memory overhead per node (~8 bytes)\n"
                            "  - Minor performance impact (~5-10%)\n\n"
                            "DISABLED:\n"
                            "  - No line/column tracking\n"
                            "  - Error messages less specific\n"
                            "  - Lower memory usage\n"
                            "  - Slightly faster parsing\n\n"
                            "ERROR COMPARISON:\n\n"
                            "With tracking enabled:\n"
                            "  ERROR at line 127, column 23:\n"
                            "  Invalid attribute 'tpye' on Action node.\n"
                            "  <Action tpye=\"Move\" target=\"enemy\"/>\n"
                            "          ^\n\n"
                            "With tracking disabled:\n"
                            "  ERROR: Invalid attribute 'tpye' on Action node.\n"
                            "  (no location information available)\n\n"
                            "USE CASES:\n"
                            "Enable when:\n"
                            "  - Developing/debugging trees\n"
                            "  - Need precise error locations\n"
                            "  - Integrating with XML editors\n\n"
                            "Disable when:\n"
                            "  - Memory is critical constraint\n"
                            "  - Maximum performance needed\n"
                            "  - Source locations not needed\n\n"
                            "RECOMMENDATION:\n"
                            "Keep ENABLED during development for better debugging.\n"
                            "Consider disabling in memory-constrained environments.";
        HelpDialog dlg(this, "Track Line/Column Numbers - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer3->Add(infoBtn3, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_trackLineColumn = new wxCheckBox(panel, wxID_ANY, "Track Line/Column Numbers");
    m_trackLineColumn->SetToolTip("Store source location for every element");
    labelSizer3->Add(m_trackLineColumn, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer3, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // SubTree expansion
    wxBoxSizer *labelSizer4 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal4(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover4(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed4(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled4(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn4 = new wxBitmapButton(panel, wxID_ANY, infoNormal4, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn4->SetBitmapHover(infoHover4);
    infoBtn4->SetBitmapPressed(infoPressed4);
    infoBtn4->SetBitmapDisabled(infoDisabled4);
    infoBtn4->SetToolTip("Click for detailed information");
    infoBtn4->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "SUBTREE EXPANSION\n"
                            "===========================================================\n\n"
                            "Controls WHEN subtree references are resolved and loaded during\n"
                            "parsing. Affects memory usage and loading performance.\n\n"
                            "THREE STRATEGIES:\n\n"
                            "1. IMMEDIATE (Default - Recommended)\n"
                            "   - All subtrees loaded and expanded during initial parse\n"
                            "   - Complete tree structure available immediately\n"
                            "   - All errors detected at load time\n"
                            "   - Higher initial memory usage\n"
                            "   - Slightly longer initial load time\n"
                            "   Pros: Simple, predictable, catches all errors early\n"
                            "   Cons: Loads trees that may never be used\n\n"
                            "2. LAZY (On-Demand Loading)\n"
                            "   - Subtrees loaded only when first accessed\n"
                            "   - Lower initial memory footprint\n"
                            "   - Faster initial load time\n"
                            "   - Subtree errors discovered at runtime\n"
                            "   - Small performance hit on first access\n"
                            "   Pros: Efficient for large tree collections\n"
                            "   Cons: Errors may appear during gameplay/execution\n\n"
                            "3. MANUAL (Explicit Control)\n"
                            "   - No automatic expansion\n"
                            "   - Application controls when to load\n"
                            "   - Maximum flexibility\n"
                            "   - Requires explicit API calls\n"
                            "   Pros: Full control over loading\n"
                            "   Cons: More complex application code\n\n"
                            "EXAMPLE:\n"
                            "Tree with subtrees: Main -> Patrol -> GuardPoint\n\n"
                            "IMMEDIATE: Main, Patrol, GuardPoint all loaded at once\n"
                            "LAZY: Only Main loaded, Patrol/GuardPoint on first use\n"
                            "MANUAL: Only Main loaded, app calls LoadSubtree() explicitly\n\n"
                            "RECOMMENDATION:\n"
                            "Use IMMEDIATE for most cases - simple and catches errors early.\n"
                            "Use LAZY for very large tree collections (100+ trees).";
        HelpDialog dlg(this, "SubTree Expansion - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer4->Add(infoBtn4, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer4->Add(new wxStaticText(panel, wxID_ANY, "SubTree Expansion:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer4, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    wxArrayString expansionChoices;
    expansionChoices.Add("Immediate");
    expansionChoices.Add("Lazy");
    expansionChoices.Add("Manual");
    m_subtreeExpansion = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, expansionChoices);
    m_subtreeExpansion->SetSelection(0);
    m_subtreeExpansion->SetToolTip("When to load and expand subtree references");
    sizer->Add(m_subtreeExpansion, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Max recursion depth
    wxBoxSizer *labelSizer5 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal5(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover5(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed5(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled5(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn5 = new wxBitmapButton(panel, wxID_ANY, infoNormal5, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn5->SetBitmapHover(infoHover5);
    infoBtn5->SetBitmapPressed(infoPressed5);
    infoBtn5->SetBitmapDisabled(infoDisabled5);
    infoBtn5->SetToolTip("Click for detailed information");
    infoBtn5->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "MAX RECURSION DEPTH\n"
                            "===========================================================\n\n"
                            "Maximum depth of nested subtree references allowed. Prevents\n"
                            "infinite recursion from circular subtree references.\n\n"
                            "WHAT IS RECURSION DEPTH?\n"
                            "The number of levels of subtree-within-subtree nesting:\n\n"
                            "Depth 1: MainTree -> SubTreeA (1 level)\n"
                            "Depth 2: MainTree -> SubTreeA -> SubTreeB (2 levels)\n"
                            "Depth 3: MainTree -> SubTreeA -> SubTreeB -> SubTreeC\n\n"
                            "CIRCULAR REFERENCE PROTECTION:\n"
                            "This limit prevents infinite loops from circular references:\n"
                            "  TreeA references TreeB\n"
                            "  TreeB references TreeA  <- CIRCULAR!\n"
                            "Without limit: Infinite expansion and stack overflow\n"
                            "With limit: Stops after N levels with clear error\n\n"
                            "VALUE GUIDELINES:\n\n"
                            "Very Low (1-10):\n"
                            "  - Simple trees with few subtree levels\n"
                            "  - Strict control over complexity\n"
                            "  - Fast circular reference detection\n\n"
                            "Medium (10-100): RECOMMENDED\n"
                            "  - Handles most reasonable tree structures\n"
                            "  - Default value: 100\n"
                            "  - Good balance of safety and flexibility\n\n"
                            "High (100-1000):\n"
                            "  - Very complex nested structures\n"
                            "  - Larger memory usage\n"
                            "  - Slower to detect circular refs\n\n"
                            "EXAMPLE ERROR:\n"
                            "Max depth = 10, actual nesting = 12:\n"
                            "  ERROR: Max recursion depth (10) exceeded.\n"
                            "  Subtree expansion stopped at: TreeA -> TreeB -> ... (10 levels)\n"
                            "  Possible circular reference detected.\n\n"
                            "RECOMMENDATION:\n"
                            "Keep default 100 - catches circular refs while allowing\n"
                            "complex legitimate nesting. Increase only if you have\n"
                            "verified deeply nested structures.";
        HelpDialog dlg(this, "Max Recursion Depth - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer5->Add(infoBtn5, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer5->Add(new wxStaticText(panel, wxID_ANY, "Max Recursion Depth:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer5, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_maxRecursionDepth = new wxSpinCtrl(panel, wxID_ANY);
    m_maxRecursionDepth->SetRange(1, 1000);
    m_maxRecursionDepth->SetValue(100);
    m_maxRecursionDepth->SetToolTip("Prevent infinite loops from circular subtree references");
    sizer->Add(m_maxRecursionDepth, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // XML namespace
    wxBoxSizer *labelSizer8 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal8(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover8(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed8(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled8(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn8 = new wxBitmapButton(panel, wxID_ANY, infoNormal8, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn8->SetBitmapHover(infoHover8);
    infoBtn8->SetBitmapPressed(infoPressed8);
    infoBtn8->SetBitmapDisabled(infoDisabled8);
    infoBtn8->SetToolTip("Click for detailed information");
    infoBtn8->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "XML NAMESPACE URI\n"
                            "===========================================================\n\n"
                            "Optional XML namespace for behavior tree elements.\n"
                            "Used for XML schema validation and element disambiguation.\n\n"
                            "WHAT IS AN XML NAMESPACE?\n"
                            "A unique identifier (usually a URI) that prevents naming\n"
                            "conflicts between XML vocabularies.\n\n"
                            "EXAMPLE WITHOUT NAMESPACE:\n"
                            "  <root>\n"
                            "    <BehaviorTree ID=\"AI\">\n"
                            "      <Sequence>...</Sequence>\n"
                            "    </BehaviorTree>\n"
                            "  </root>\n\n"
                            "EXAMPLE WITH NAMESPACE:\n"
                            "  <root xmlns:bt=\"http://behaviortree.dev/bt/1.0\">\n"
                            "    <bt:BehaviorTree ID=\"AI\">\n"
                            "      <bt:Sequence>...</bt:Sequence>\n"
                            "    </bt:BehaviorTree>\n"
                            "  </root>\n\n"
                            "WHEN TO USE:\n\n"
                            "Leave Empty (Most Common):\n"
                            "  - Simple XML files\n"
                            "  - No naming conflicts\n"
                            "  - Cleaner XML\n"
                            "  - Easier to read/write\n\n"
                            "Specify Namespace When:\n"
                            "  - Mixing multiple XML vocabularies\n"
                            "  - Need formal XML schema validation\n"
                            "  - Working with XML tools that require it\n"
                            "  - Preventing element name collisions\n\n"
                            "COMMON NAMESPACE FORMATS:\n"
                            "  - http://behaviortree.dev/bt/1.0\n"
                            "  - urn:behaviortree:schema:1.0\n"
                            "  - http://example.com/schemas/bt\n\n"
                            "Note: The URI doesn't need to be a real web address.\n"
                            "It's just a unique identifier.\n\n"
                            "IMPACT:\n"
                            "If specified, all behavior tree elements must use the\n"
                            "namespace prefix in your XML files.\n\n"
                            "RECOMMENDATION:\n"
                            "Leave empty unless you have specific requirements for\n"
                            "namespace-based XML validation or element disambiguation.";
        HelpDialog dlg(this, "XML Namespace - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer8->Add(infoBtn8, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    labelSizer8->Add(new wxStaticText(panel, wxID_ANY, "XML Namespace URI:"), 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer8, wxGBPosition(row, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
    m_xmlNamespace = new wxTextCtrl(panel, wxID_ANY);
    m_xmlNamespace->SetToolTip("Optional namespace URI (e.g., http://behaviortree.dev/bt/1.0)");
    sizer->Add(m_xmlNamespace, wxGBPosition(row, 1), wxDefaultSpan, wxEXPAND);
    row++;
 
    // Preserve comments
    wxBoxSizer *labelSizer9 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal9(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover9(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed9(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled9(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn9 = new wxBitmapButton(panel, wxID_ANY, infoNormal9, wxDefaultPosition, wxSize(40, 40),
                                                  wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn9->SetBitmapHover(infoHover9);
    infoBtn9->SetBitmapPressed(infoPressed9);
    infoBtn9->SetBitmapDisabled(infoDisabled9);
    infoBtn9->SetToolTip("Click for detailed information");
    infoBtn9->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "PRESERVE XML COMMENTS\n"
                            "===========================================================\n\n"
                            "Controls whether XML comments are kept in memory after parsing.\n\n"
                            "ENABLED:\n"
                            "  - Comments stored in parsed tree structure\n"
                            "  - Can be accessed programmatically\n"
                            "  - Preserved when saving/exporting trees\n"
                            "  - Useful for round-trip editing\n"
                            "  - Small memory overhead\n\n"
                            "DISABLED (Default):\n"
                            "  - Comments discarded during parsing\n"
                            "  - Lower memory usage\n"
                            "  - Slightly faster parsing\n"
                            "  - Lost if tree is saved back to XML\n\n"
                            "XML COMMENTS:\n"
                            "  <!-- This is a comment -->\n"
                            "  <!-- Comments can span\n"
                            "       multiple lines -->\n\n"
                            "EXAMPLE:\n"
                            "  <BehaviorTree ID=\"AI\">\n"
                            "    <!-- This is the patrol sequence -->\n"
                            "    <Sequence>\n"
                            "      <Action name=\"Move\"/>  <!-- Move forward -->\n"
                            "    </Sequence>\n"
                            "  </BehaviorTree>\n\n"
                            "USE CASES:\n\n"
                            "Enable when:\n"
                            "  - Building XML editor/viewer\n"
                            "  - Need to preserve documentation\n"
                            "  - Round-trip editing (load -> modify -> save)\n"
                            "  - Comments contain important metadata\n\n"
                            "Disable when:\n"
                            "  - Only loading trees for execution\n"
                            "  - Memory is constrained\n"
                            "  - Comments are just temporary notes\n"
                            "  - Maximum parsing speed needed\n\n"
                            "RECOMMENDATION:\n"
                            "Enable if building an editor or if comments contain important\n"
                            "information. Disable for runtime-only tree loading.";
        HelpDialog dlg(this, "Preserve Comments - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer9->Add(infoBtn9, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_preserveComments = new wxCheckBox(panel, wxID_ANY, "Preserve XML Comments");
    m_preserveComments->SetToolTip("Keep comments in memory for round-trip editing");
    labelSizer9->Add(m_preserveComments, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer9, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    // Preserve attribute order
    wxBoxSizer *labelSizer10 = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal10(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover10(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed10(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled10(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn10 = new wxBitmapButton(panel, wxID_ANY, infoNormal10, wxDefaultPosition, wxSize(40, 40),
                                                   wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn10->SetBitmapHover(infoHover10);
    infoBtn10->SetBitmapPressed(infoPressed10);
    infoBtn10->SetBitmapDisabled(infoDisabled10);
    infoBtn10->SetToolTip("Click for detailed information");
    infoBtn10->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "PRESERVE ATTRIBUTE ORDER\n"
                            "===========================================================\n\n"
                            "Controls whether the order of XML attributes is maintained\n"
                            "exactly as they appear in the source file.\n\n"
                            "ENABLED:\n"
                            "  - Attributes stored in original order\n"
                            "  - When saved, attributes appear in same order\n"
                            "  - Useful for version control (minimal diffs)\n"
                            "  - Slight memory/performance overhead\n"
                            "  - Better for human-edited XML\n\n"
                            "DISABLED (Default):\n"
                            "  - Attributes may be reordered internally\n"
                            "  - Typically alphabetical order\n"
                            "  - Slightly more efficient\n"
                            "  - Doesn't affect functionality\n"
                            "  - Standard XML behavior\n\n"
                            "XML ATTRIBUTE ORDER:\n\n"
                            "Original XML:\n"
                            "  <Action name=\"Move\" speed=\"5.0\" target=\"enemy\"/>\n\n"
                            "Preserved (enabled):\n"
                            "  <Action name=\"Move\" speed=\"5.0\" target=\"enemy\"/>\n"
                            "  (Exact same order)\n\n"
                            "Not preserved (disabled):\n"
                            "  <Action name=\"Move\" speed=\"5.0\" target=\"enemy\"/>\n"
                            "  (May become: name, speed, target OR alphabetically)\n\n"
                            "IMPORTANT NOTE:\n"
                            "XML specification says attribute order is NOT significant.\n"
                            "All XML parsers must work regardless of attribute order.\n\n"
                            "USE CASES:\n\n"
                            "Enable when:\n"
                            "  - Using version control (Git, SVN)\n"
                            "  - Want minimal diffs between versions\n"
                            "  - Hand-editing XML files\n"
                            "  - Order has semantic meaning to humans\n\n"
                            "Disable when:\n"
                            "  - Pure runtime loading\n"
                            "  - No round-trip editing\n"
                            "  - Programmatically generated XML\n"
                            "  - Order doesn't matter\n\n"
                            "RECOMMENDATION:\n"
                            "Enable for editor applications and version-controlled files.\n"
                            "Disable for runtime-only loading.";
        HelpDialog dlg(this, "Preserve Attribute Order - Help", helpText);
        dlg.ShowModal();
    });
    labelSizer10->Add(infoBtn10, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    m_preserveAttrOrder = new wxCheckBox(panel, wxID_ANY, "Preserve Attribute Order");
    m_preserveAttrOrder->SetToolTip("Maintain original attribute order for version control");
    labelSizer10->Add(m_preserveAttrOrder, 0, wxALIGN_CENTER_VERTICAL);
    sizer->Add(labelSizer10, wxGBPosition(row, 0), wxGBSpan(1, 2));
    row++;
 
    sizer->AddGrowableCol(1);
    mainSizer->Add(sizer, 0, wxEXPAND | wxALL, 5);
 
    // Add separator line
    mainSizer->Add(new wxStaticLine(panel), 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, 5);
 
    // Custom validation rules section with toggle
    // Toggle checkbox for enabling/disabling custom validation
    m_enableCustomValidation = new wxCheckBox(panel, ID_TOGGLE_CUSTOM_VALIDATION, "Enable Custom Validation Rules");
    m_enableCustomValidation->SetValue(false); // Disabled by default
    m_enableCustomValidation->SetToolTip("Toggle custom validation rules on/off");
    mainSizer->Add(m_enableCustomValidation, 0, wxALL, 5);
 
    // Custom validation rules (multiline)
    wxBoxSizer *rulesLabelSizer = new wxBoxSizer(wxHORIZONTAL);
    wxBitmap infoNormal11(GetResourcePath("buttons/info/Info_Normal_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoHover11(GetResourcePath("buttons/info/Info_Hovered_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoPressed11(GetResourcePath("buttons/info/Info_Pressed_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmap infoDisabled11(GetResourcePath("buttons/info/Info_Disabled_20.png"), wxBITMAP_TYPE_PNG);
    wxBitmapButton *infoBtn11 = new wxBitmapButton(panel, wxID_ANY, infoNormal11, wxDefaultPosition, wxSize(40, 40),
                                                   wxBORDER_NONE | wxBU_EXACTFIT);
    infoBtn11->SetBitmapHover(infoHover11);
    infoBtn11->SetBitmapPressed(infoPressed11);
    infoBtn11->SetBitmapDisabled(infoDisabled11);
    infoBtn11->SetToolTip("Click for detailed information");
    infoBtn11->Bind(wxEVT_BUTTON, [this](wxCommandEvent &) {
        wxString helpText = "CUSTOM VALIDATION RULES\n"
                            "===========================================================\n\n"
                            "Define custom validation logic beyond standard XML schema validation.\n"
                            "Specify rules using a simple scripting language or expressions.\n\n"
                            "WHAT ARE VALIDATION RULES?\n"
                            "Custom constraints that your behavior trees must satisfy:\n"
                            "  - Structural rules (e.g., Sequence must have 2+ children)\n"
                            "  - Naming conventions (e.g., Actions must start with verb)\n"
                            "  - Business logic (e.g., no more than 3 decorators deep)\n"
                            "  - Cross-tree references (e.g., all subtrees must exist)\n\n"
                            "RULE FORMAT:\n"
                            "One rule per line. Each rule has:\n"
                            "  - Condition: When to check\n"
                            "  - Validation: What to verify\n"
                            "  - Message: Error to show if fails\n\n"
                            "EXAMPLE RULES:\n\n"
                            "1. Structural Rule:\n"
                            "   node.type == 'Sequence' && node.children.count < 2:\n"
                            "     'Sequence nodes must have at least 2 children'\n\n"
                            "2. Naming Convention:\n"
                            "   node.type == 'Action' && !node.name.startsWithVerb():\n"
                            "     'Action names must start with a verb'\n\n"
                            "3. Decorator Depth:\n"
                            "   node.type == 'Decorator' && node.depth > 3:\n"
                            "     'Decorators cannot be nested more than 3 levels'\n\n"
                            "4. Required Attributes:\n"
                            "   node.type == 'Action' && !node.hasAttribute('timeout'):\n"
                            "     'All actions must specify a timeout'\n\n"
                            "5. Subtree References:\n"
                            "   node.type == 'SubTree' && !subtreeExists(node.ID):\n"
                            "     'Referenced subtree does not exist'\n\n"
                            "AVAILABLE PROPERTIES:\n"
                            "  - node.type: Node type (Action, Sequence, etc.)\n"
                            "  - node.name: Node name/ID\n"
                            "  - node.children.count: Number of child nodes\n"
                            "  - node.depth: Nesting level\n"
                            "  - node.attributes: Map of attributes\n"
                            "  - tree.ID: Current tree identifier\n\n"
                            "WHEN VALIDATION RUNS:\n"
                            "  - After parsing completes\n"
                            "  - Before tree is made available to application\n"
                            "  - All rules checked, multiple errors reported\n\n"
                            "ERROR HANDLING:\n"
                            "If any rule fails:\n"
                            "  - Clear error message shown\n"
                            "  - Parse operation fails\n"
                            "  - Tree not loaded into memory\n\n"
                            "PERFORMANCE:\n"
                            "  - Rules checked once at parse time\n"
                            "  - No runtime overhead\n"
                            "  - Complex rules may slow initial load\n\n"
                            "RECOMMENDATION:\n"
                            "Use for project-specific constraints that can't be expressed\n"
                            "in XML schema. Keep rules simple and clear. Too many complex\n"
                            "rules can make debugging difficult.";
        HelpDialog dlg(this, "Custom Validation Rules - Help", helpText);
        dlg.ShowModal();
    });
    rulesLabelSizer->Add(infoBtn11, 0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
    rulesLabelSizer->Add(new wxStaticText(panel, wxID_ANY, "Custom Validation Rules: ( experimental )"), 0,
                         wxALIGN_CENTER_VERTICAL);
    mainSizer->Add(rulesLabelSizer, 0, wxEXPAND | wxLEFT | wxRIGHT | wxTOP, 5);
    m_customValidation = new wxTextCtrl(panel, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE);
    m_customValidation->SetMinSize(wxSize(-1, 100));
    m_customValidation->SetToolTip("Define custom validation expressions (one rule per line)");
    m_customValidation->Enable(false); // Disabled by default (matches checkbox state)
    mainSizer->Add(m_customValidation, 1, wxEXPAND | wxALL, 5);
 
    panel->SetSizer(mainSizer);
    return panel;
}
 
wxPanel *ParserConfigDialog::CreateBottomPanel(wxWindow *parent) {
    wxPanel *panel = new wxPanel(parent);
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Profile metadata
    wxGridBagSizer *metaSizer = new wxGridBagSizer(5, 5);
 
    metaSizer->Add(new wxStaticText(panel, wxID_ANY, "Profile Name:"), wxGBPosition(0, 0), wxDefaultSpan,
                   wxALIGN_CENTER_VERTICAL);
    m_profileName = new wxTextCtrl(panel, wxID_ANY);
    metaSizer->Add(m_profileName, wxGBPosition(0, 1), wxDefaultSpan, wxEXPAND);
 
    metaSizer->Add(new wxStaticText(panel, wxID_ANY, "Description:"), wxGBPosition(1, 0), wxDefaultSpan, wxALIGN_TOP);
    m_profileDescription = new wxTextCtrl(panel, wxID_ANY, "", wxDefaultPosition, wxSize(-1, 60), wxTE_MULTILINE);
    metaSizer->Add(m_profileDescription, wxGBPosition(1, 1), wxDefaultSpan, wxEXPAND);
 
    metaSizer->AddGrowableCol(1);
    mainSizer->Add(metaSizer, 0, wxEXPAND | wxALL, 5);
 
    // Buttons
    wxBoxSizer *btnSizer = new wxBoxSizer(wxHORIZONTAL);
 
    m_testValidateBtn = new wxButton(panel, ID_TEST_VALIDATE, "Test/Validate");
    btnSizer->Add(m_testValidateBtn, 0, wxALL, 2);
 
    m_previewJSONBtn = new wxButton(panel, ID_PREVIEW_JSON, "Preview JSON");
    btnSizer->Add(m_previewJSONBtn, 0, wxALL, 2);
 
    m_resetDefaultsBtn = new wxButton(panel, ID_RESET_DEFAULTS, "Reset to Defaults");
    btnSizer->Add(m_resetDefaultsBtn, 0, wxALL, 2);
 
    btnSizer->AddStretchSpacer();
 
    m_saveBtn = new wxButton(panel, ID_SAVE, "Save");
    btnSizer->Add(m_saveBtn, 0, wxALL, 2);
 
    m_saveAsBtn = new wxButton(panel, ID_SAVE_AS, "Save As...");
    btnSizer->Add(m_saveAsBtn, 0, wxALL, 2);
 
    m_cancelBtn = new wxButton(panel, wxID_CANCEL, "Cancel");
    btnSizer->Add(m_cancelBtn, 0, wxALL, 2);
 
    mainSizer->Add(btnSizer, 0, wxEXPAND | wxALL, 5);
 
    panel->SetSizer(mainSizer);
    return panel;
}
 
// This file is getting too long. I'll continue with event handlers in the next part...
// For now, let me add placeholder implementations
 
void ParserConfigDialog::LoadProfiles() {
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    auto profileNames = configMgr.GetProfileNames();
    wxString activeName(configMgr.GetActiveProfileName());
 
    m_profileList->DeleteAllItems();
 
    long activeIndex = -1;
    for (size_t i = 0; i < profileNames.size(); ++i) {
        const auto &name = profileNames[i];
 
        // Add visual marker (*) for active profile and color it green
        wxString displayName = name;
        bool isActive = (name == activeName);
 
        if (isActive) {
            displayName = wxString::FromUTF8("* ") + name; // Safe Unicode handling
            activeIndex = i;
        }
 
        // Insert item into list
        long index = m_profileList->InsertItem(i, displayName);
 
        // Set color: green for active, white for others
        if (isActive) {
            m_profileList->SetItemTextColour(index, wxColour(46, 125, 50)); // Dark green
        } else {
            m_profileList->SetItemTextColour(index, *wxWHITE); // White for inactive
        }
    }
 
    // Select and load active profile
    if (activeIndex != -1) {
        m_profileList->SetItemState(activeIndex, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
        m_profileList->EnsureVisible(activeIndex);
        auto profile = configMgr.GetProfile(activeName.ToStdString());
        LoadProfileData(profile);
    }
}
 
void ParserConfigDialog::LoadProfileData(std::shared_ptr<EmberCore::ParserProfile> profile) {
    if (!profile)
        return;
 
    m_currentProfile = profile;
    m_profileName->SetValue(profile->GetName());
    m_profileDescription->SetValue(profile->GetDescription());
 
    SetUIFromConfig(profile->GetConfig());
    m_modified = false;
}
 
void ParserConfigDialog::SetUIFromConfig(const EmberCore::ParserConfig &config) {
    // Tab 1: Document Structure
    const auto &docConfig = config.GetDocumentConfig();
    m_rootElement->SetValue(docConfig.root_element);
    m_mainTreeAttr->SetValue(docConfig.main_tree_attribute);
    m_caseSensitive->SetValue(docConfig.case_sensitive);
    m_allowUnknownElements->SetValue(docConfig.allow_unknown_elements);
    m_whitespaceHandling->SetSelection(static_cast<int>(docConfig.whitespace_handling));
 
    // Set naming convention checkboxes
    m_namingConventionStrict->SetValue(docConfig.naming_convention ==
                                       EmberCore::ParserConfig::NamingConvention::STRICT);
    m_namingConventionBalanced->SetValue(docConfig.naming_convention ==
                                         EmberCore::ParserConfig::NamingConvention::BALANCED);
    m_namingConventionLoose->SetValue(docConfig.naming_convention == EmberCore::ParserConfig::NamingConvention::LOOSE);
 
    // Tab 2: Tree Elements
    const auto &treeConfig = config.GetTreeConfig();
    m_behaviorTreeElement->SetValue(treeConfig.behavior_tree_element);
    m_treeIdAttr->SetValue(treeConfig.tree_id_attribute);
    m_allowMultipleTrees->SetValue(treeConfig.allow_multiple_trees);
    m_subtreeElement->SetValue(treeConfig.subtree_element);
    m_subtreeRefAttr->SetValue(treeConfig.subtree_reference_attribute);
    m_validateStructure->SetValue(treeConfig.validate_tree_structure);
    m_requireRootNode->SetValue(treeConfig.require_root_node);
 
    // Tab 3: Node Elements
    const auto &nodeConfig = config.GetNodeConfig();
    m_controlElement->SetValue(nodeConfig.control_element);
    m_actionElement->SetValue(nodeConfig.action_element);
    m_conditionElement->SetValue(nodeConfig.condition_element);
    m_decoratorElement->SetValue(nodeConfig.decorator_element);
    m_genericNodeElement->SetValue(nodeConfig.generic_node_element);
    m_nodeIdAttr->SetValue(nodeConfig.node_id_attribute);
    m_nodeNameAttr->SetValue(nodeConfig.node_name_attribute);
    m_nodeTypeAttr->SetValue(nodeConfig.node_type_attribute);
    m_allowCustomAttrs->SetValue(nodeConfig.allow_custom_attributes);
 
    // Tab 4: Node Classification
    const auto &classConfig = config.GetClassificationConfig();
    m_classificationStrategy->SetSelection(static_cast<int>(classConfig.strategy));
 
    m_controlTypesList->Clear();
    for (const auto &type : classConfig.control_types) {
        m_controlTypesList->Append(type);
    }
 
    m_decoratorTypesList->Clear();
    for (const auto &type : classConfig.decorator_types) {
        m_decoratorTypesList->Append(type);
    }
 
    m_actionTypesList->Clear();
    for (const auto &type : classConfig.action_types) {
        m_actionTypesList->Append(type);
    }
 
    m_conditionTypesList->Clear();
    for (const auto &type : classConfig.condition_types) {
        m_conditionTypesList->Append(type);
    }
 
    m_unknownBehavior->SetSelection(static_cast<int>(classConfig.unknown_behavior));
    m_typeAttrName->SetValue(classConfig.type_attribute_name);
 
    // Tab 5: Blackboard
    const auto &bbConfig = config.GetBlackboardConfig();
    m_blackboardElement->SetValue(bbConfig.blackboard_element);
    m_blackboardIdAttr->SetValue(bbConfig.blackboard_id_attribute);
    m_blackboardParentAttr->SetValue(bbConfig.parent_attribute);
    m_entryElement->SetValue(bbConfig.entry_element);
    m_entryKeyAttr->SetValue(bbConfig.entry_key_attribute);
    m_entryTypeAttr->SetValue(bbConfig.entry_type_attribute);
    m_entryValueAttr->SetValue(bbConfig.entry_value_attribute);
    m_allowUndefinedKeys->SetValue(bbConfig.allow_undefined_keys);
 
    // Type mappings
    if (m_typeMappingsGrid->GetNumberRows() > 0) {
        m_typeMappingsGrid->DeleteRows(0, m_typeMappingsGrid->GetNumberRows());
    }
    for (const auto &mapping : bbConfig.type_mappings) {
        int row = m_typeMappingsGrid->GetNumberRows();
        m_typeMappingsGrid->AppendRows(1);
        m_typeMappingsGrid->SetCellValue(row, 0, mapping.first);
        m_typeMappingsGrid->SetCellValue(row, 1, mapping.second);
    }
 
    // Tab 6: Advanced
    const auto &advConfig = config.GetAdvancedConfig();
    m_enableProgressReporting->SetValue(advConfig.enable_progress_reporting);
    m_detailedErrors->SetValue(advConfig.detailed_error_messages);
    m_trackLineColumn->SetValue(advConfig.track_line_column);
    m_subtreeExpansion->SetSelection(static_cast<int>(advConfig.subtree_expansion));
    m_maxRecursionDepth->SetValue(advConfig.max_recursion_depth);
    m_xmlNamespace->SetValue(advConfig.xml_namespace_uri);
    m_preserveComments->SetValue(advConfig.preserve_comments);
    m_preserveAttrOrder->SetValue(advConfig.preserve_attribute_order);
    m_customValidation->SetValue(advConfig.custom_validation_rules);
 
    // Enable the custom validation toggle if there are rules loaded
    bool hasCustomRules = !advConfig.custom_validation_rules.empty();
    m_enableCustomValidation->SetValue(hasCustomRules);
    m_customValidation->Enable(hasCustomRules);
}
 
// Placeholder event handlers - full implementation would go here
void ParserConfigDialog::OnProfileSelected(wxListEvent &event) {
    long selectedIndex = m_profileList->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    if (selectedIndex == -1)
        return;
 
    wxString profileName = m_profileList->GetItemText(selectedIndex);
 
    // Remove the "* " prefix if present (active profile marker)
    if (profileName.StartsWith(wxString::FromUTF8("* "))) {
        profileName = profileName.Mid(2); // Skip first 2 characters
    }
 
    // Save the current profile before switching if there are changes
    SaveCurrentProfileIfModified();
 
    // Now load the new profile
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    auto profile = configMgr.GetProfile(profileName.ToStdString());
    LoadProfileData(profile);
}
 
void ParserConfigDialog::OnNewProfile(wxCommandEvent &event) {
    // Save current profile before creating a new one
    SaveCurrentProfileIfModified();
 
    wxTextEntryDialog dialog(this, "Enter new profile name:", "New Profile");
    if (dialog.ShowModal() == wxID_OK) {
        wxString name = dialog.GetValue();
        if (!name.IsEmpty()) {
            auto profile = std::make_shared<EmberCore::ParserProfile>(name.ToStdString(), "");
            auto &configMgr = EmberCore::ConfigManager::GetInstance();
            if (configMgr.AddProfile(profile)) {
                LoadProfiles();
 
                // Find and select the new profile
                long index = m_profileList->FindItem(-1, name);
                if (index != wxNOT_FOUND) {
                    m_profileList->SetItemState(index, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
                    m_profileList->EnsureVisible(index);
                    LoadProfileData(profile);
                }
            }
        }
    }
}
 
void ParserConfigDialog::OnCloneProfile(wxCommandEvent &event) {
    if (!m_currentProfile)
        return;
 
    // First, save any unsaved changes to the current profile
    SaveCurrentProfileIfModified();
 
    wxTextEntryDialog dialog(this, "Enter name for cloned profile:", "Clone Profile",
                             m_currentProfile->GetName() + " (Copy)");
    if (dialog.ShowModal() == wxID_OK) {
        wxString name = dialog.GetValue();
        if (!name.IsEmpty()) {
            // Clone the profile with its current (saved) state
            auto cloned = m_currentProfile->Clone(name.ToStdString());
            auto &configMgr = EmberCore::ConfigManager::GetInstance();
            if (configMgr.AddProfile(cloned)) {
                LoadProfiles();
 
                // Find and select the cloned profile
                long index = m_profileList->FindItem(-1, name);
                if (index != wxNOT_FOUND) {
                    m_profileList->SetItemState(index, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
                    m_profileList->EnsureVisible(index);
                    LoadProfileData(cloned);
                }
            }
        }
    }
}
 
void ParserConfigDialog::OnDeleteProfile(wxCommandEvent &event) {
    long selectedIndex = m_profileList->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    if (selectedIndex == -1)
        return;
 
    wxString profileName = m_profileList->GetItemText(selectedIndex);
 
    // Remove the "* " prefix if present (active profile marker)
    if (profileName.StartsWith(wxString::FromUTF8("* "))) {
        profileName = profileName.Mid(2);
    }
 
    if (wxMessageBox("Are you sure you want to delete this profile?", "Confirm Delete", wxYES_NO | wxICON_QUESTION,
                     this) == wxYES) {
        auto &configMgr = EmberCore::ConfigManager::GetInstance();
        if (configMgr.RemoveProfile(profileName.ToStdString())) {
            LoadProfiles();
        }
    }
}
 
void ParserConfigDialog::OnImportProfile(wxCommandEvent &event) {
    // Save current profile before importing a new one
    SaveCurrentProfileIfModified();
 
    // Use the profiles directory as default
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    wxString defaultDir = wxString(configMgr.GetProfilesDirectory());
 
    wxFileDialog dialog(this, "Import Profile", defaultDir, "", "JSON files (*.json)|*.json",
                        wxFD_OPEN | wxFD_FILE_MUST_EXIST);
    if (dialog.ShowModal() == wxID_OK) {
        if (configMgr.ImportProfile(dialog.GetPath().ToStdString(), false)) {
            LoadProfiles();
            wxMessageBox("Profile imported successfully", "Success", wxOK | wxICON_INFORMATION, this);
        } else {
            wxMessageBox("Failed to import profile", "Error", wxOK | wxICON_ERROR, this);
        }
    }
}
 
void ParserConfigDialog::OnExportProfile(wxCommandEvent &event) {
    if (!m_currentProfile)
        return;
 
    // Update profile with current UI state before exporting
    SaveCurrentProfileIfModified();
 
    // Use the profiles directory as default
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    wxString defaultDir = wxString(configMgr.GetProfilesDirectory());
    wxString defaultFilename = m_currentProfile->GetName() + ".json";
 
    wxFileDialog dialog(this, "Export Profile", defaultDir, defaultFilename, "JSON files (*.json)|*.json",
                        wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 
    if (dialog.ShowModal() == wxID_OK) {
        wxString selectedPath = dialog.GetPath();
        wxFileName selectedFile(selectedPath);
        wxFileName defaultDirPath(defaultDir);
 
        // Check if export location is outside the default profiles directory
        bool isOutsideDefaultDir = !selectedFile.GetPath().StartsWith(defaultDirPath.GetFullPath());
 
        if (isOutsideDefaultDir) {
            int result = wxMessageBox("You are exporting to a location outside the default profiles directory.\n\n"
                                      "Default: " +
                                          defaultDir +
                                          "\n"
                                          "Selected: " +
                                          selectedFile.GetPath() +
                                          "\n\n"
                                          "Are you sure you want to export here?",
                                      "Confirm Export Location", wxYES_NO | wxICON_QUESTION, this);
 
            if (result != wxYES) {
                return; // User cancelled
            }
        }
 
        if (configMgr.ExportProfile(m_currentProfile->GetName(), selectedPath.ToStdString())) {
            wxMessageBox("Profile exported successfully to:\n" + selectedPath, "Success", wxOK | wxICON_INFORMATION,
                         this);
        } else {
            wxMessageBox("Failed to export profile", "Error", wxOK | wxICON_ERROR, this);
        }
    }
}
 
void ParserConfigDialog::OnSetActiveProfile(wxCommandEvent &event) {
    if (!m_currentProfile)
        return;
 
    // Save any changes before setting as active
    SaveCurrentProfileIfModified();
 
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    configMgr.SetActiveProfile(m_currentProfile->GetName());
 
    // Refresh list to show new active marker (*)
    LoadProfiles();
 
    wxMessageBox("Active profile set to: " + m_currentProfile->GetName(), "Success", wxOK | wxICON_INFORMATION, this);
}
 
void ParserConfigDialog::OnTestValidate(wxCommandEvent &event) {
    wxString errorMsg;
    if (ValidateCurrentConfig(errorMsg)) {
        wxMessageBox("✓ Configuration is valid!\n\nAll required fields are filled and properly configured.",
                     "Validation Success", wxOK | wxICON_INFORMATION, this);
    } else {
        // Use a custom dialog for better error display
        wxDialog errorDlg(this, wxID_ANY, "Configuration Validation Failed", wxDefaultPosition, wxSize(800, 600));
        wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
 
        // Title/icon row
        wxBoxSizer *titleSizer = new wxBoxSizer(wxHORIZONTAL);
        wxStaticText *titleText = new wxStaticText(&errorDlg, wxID_ANY, "⚠ Configuration Validation Errors");
        wxFont titleFont = titleText->GetFont();
        titleFont.SetPointSize(12);
        titleFont.SetWeight(wxFONTWEIGHT_BOLD);
        titleText->SetFont(titleFont);
        titleText->SetForegroundColour(wxColour(255, 100, 100));
        titleSizer->Add(titleText, 0, wxALL, 10);
        sizer->Add(titleSizer, 0, wxEXPAND);
 
        // Error message text control
        wxTextCtrl *textCtrl = new wxTextCtrl(&errorDlg, wxID_ANY, errorMsg, wxDefaultPosition, wxDefaultSize,
                                              wxTE_MULTILINE | wxTE_READONLY | wxTE_WORDWRAP);
 
        // Use monospace font for better readability
        wxFont monoFont(10, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
        textCtrl->SetFont(monoFont);
 
        // Dark theme
        textCtrl->SetBackgroundColour(wxColour(50, 50, 50));
        textCtrl->SetForegroundColour(wxColour(255, 255, 255));
 
        sizer->Add(textCtrl, 1, wxEXPAND | wxALL, 10);
 
        // Close button
        wxButton *closeBtn = new wxButton(&errorDlg, wxID_OK, "Close");
        sizer->Add(closeBtn, 0, wxALIGN_CENTER | wxALL, 10);
 
        errorDlg.SetSizer(sizer);
        errorDlg.ShowModal();
    }
}
 
void ParserConfigDialog::OnPreviewJSON(wxCommandEvent &event) {
    if (!m_currentProfile)
        return;
 
    auto config = GetConfigFromUI();
    m_currentProfile->SetConfig(*config);
 
    auto json = m_currentProfile->ToJson();
    wxString jsonStr(json.dump(4));
 
    wxDialog previewDlg(this, wxID_ANY, "JSON Preview", wxDefaultPosition, wxSize(600, 500));
    wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);
    wxTextCtrl *textCtrl = new wxTextCtrl(&previewDlg, wxID_ANY, jsonStr, wxDefaultPosition, wxDefaultSize,
                                          wxTE_MULTILINE | wxTE_READONLY);
    sizer->Add(textCtrl, 1, wxEXPAND | wxALL, 10);
    wxButton *closeBtn = new wxButton(&previewDlg, wxID_OK, "Close");
    sizer->Add(closeBtn, 0, wxALIGN_CENTER | wxALL, 10);
    previewDlg.SetSizer(sizer);
    previewDlg.ShowModal();
}
 
void ParserConfigDialog::OnResetDefaults(wxCommandEvent &event) {
    if (wxMessageBox("Reset current profile to default values?", "Confirm Reset", wxYES_NO | wxICON_QUESTION, this) ==
        wxYES) {
        auto defaultConfig = EmberCore::ParserConfig::CreateDefault();
        SetUIFromConfig(defaultConfig);
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnSave(wxCommandEvent &event) {
    SaveCurrentProfile();
    EndModal(wxID_OK);
}
 
void ParserConfigDialog::OnSaveAs(wxCommandEvent &event) {
    wxTextEntryDialog dialog(this, "Enter name for new profile:", "Save As");
    if (dialog.ShowModal() == wxID_OK) {
        wxString name = dialog.GetValue();
        if (!name.IsEmpty()) {
            auto profile = std::make_shared<EmberCore::ParserProfile>(name.ToStdString(),
                                                                      m_profileDescription->GetValue().ToStdString());
            auto config = GetConfigFromUI();
            profile->SetConfig(*config);
 
            auto &configMgr = EmberCore::ConfigManager::GetInstance();
            if (configMgr.AddProfile(profile)) {
                m_currentProfile = profile;
                LoadProfiles();
                wxMessageBox("Profile saved as: " + name, "Success", wxOK | wxICON_INFORMATION, this);
            }
        }
    }
}
 
void ParserConfigDialog::OnCancel(wxCommandEvent &event) {
    if (m_modified) {
        if (wxMessageBox("Discard unsaved changes?", "Confirm Cancel", wxYES_NO | wxICON_QUESTION, this) != wxYES) {
            return;
        }
    }
    EndModal(wxID_CANCEL);
}
 
// Add/Remove button handlers (simplified implementations)
void ParserConfigDialog::OnAddControlType(wxCommandEvent &event) {
    wxTextEntryDialog dialog(this, "Enter control type name:", "Add Control Type");
    if (dialog.ShowModal() == wxID_OK && !dialog.GetValue().IsEmpty()) {
        m_controlTypesList->Append(dialog.GetValue());
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnRemoveControlType(wxCommandEvent &event) {
    int sel = m_controlTypesList->GetSelection();
    if (sel != wxNOT_FOUND) {
        m_controlTypesList->Delete(sel);
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnAddDecoratorType(wxCommandEvent &event) {
    wxTextEntryDialog dialog(this, "Enter decorator type name:", "Add Decorator Type");
    if (dialog.ShowModal() == wxID_OK && !dialog.GetValue().IsEmpty()) {
        m_decoratorTypesList->Append(dialog.GetValue());
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnRemoveDecoratorType(wxCommandEvent &event) {
    int sel = m_decoratorTypesList->GetSelection();
    if (sel != wxNOT_FOUND) {
        m_decoratorTypesList->Delete(sel);
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnAddActionType(wxCommandEvent &event) {
    wxTextEntryDialog dialog(this, "Enter action type name:", "Add Action Type");
    if (dialog.ShowModal() == wxID_OK && !dialog.GetValue().IsEmpty()) {
        m_actionTypesList->Append(dialog.GetValue());
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnRemoveActionType(wxCommandEvent &event) {
    int sel = m_actionTypesList->GetSelection();
    if (sel != wxNOT_FOUND) {
        m_actionTypesList->Delete(sel);
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnAddConditionType(wxCommandEvent &event) {
    wxTextEntryDialog dialog(this, "Enter condition type name:", "Add Condition Type");
    if (dialog.ShowModal() == wxID_OK && !dialog.GetValue().IsEmpty()) {
        m_conditionTypesList->Append(dialog.GetValue());
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnRemoveConditionType(wxCommandEvent &event) {
    int sel = m_conditionTypesList->GetSelection();
    if (sel != wxNOT_FOUND) {
        m_conditionTypesList->Delete(sel);
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnAddTypeMapping(wxCommandEvent &event) {
    m_typeMappingsGrid->AppendRows(1);
    m_modified = true;
}
 
void ParserConfigDialog::OnRemoveTypeMapping(wxCommandEvent &event) {
    wxArrayInt rows = m_typeMappingsGrid->GetSelectedRows();
    if (rows.GetCount() > 0) {
        m_typeMappingsGrid->DeleteRows(rows[0], 1);
        m_modified = true;
    }
}
 
void ParserConfigDialog::OnToggleCustomValidation(wxCommandEvent &event) {
    bool enabled = m_enableCustomValidation->GetValue();
    m_customValidation->Enable(enabled);
 
    // If disabling, optionally clear the content to make it clear no rules are active
    // Uncomment the next line if you want to clear rules when disabling
    // if (!enabled) m_customValidation->Clear();
 
    m_modified = true;
}
 
void ParserConfigDialog::SaveCurrentProfile() {
    if (!m_currentProfile)
        return;
 
    m_currentProfile->SetName(m_profileName->GetValue().ToStdString());
    m_currentProfile->SetDescription(m_profileDescription->GetValue().ToStdString());
 
    auto config = GetConfigFromUI();
    m_currentProfile->SetConfig(*config);
 
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    configMgr.SaveProfile(m_currentProfile->GetName());
 
    m_modified = false;
}
 
void ParserConfigDialog::SaveCurrentProfileIfModified() {
    if (m_currentProfile && m_modified) {
        SaveCurrentProfile();
    }
}
 
std::shared_ptr<EmberCore::ParserConfig> ParserConfigDialog::GetConfigFromUI() {
    auto config = std::make_shared<EmberCore::ParserConfig>();
 
    // Tab 1: Document Structure
    auto &docConfig = config->GetDocumentConfig();
    docConfig.root_element = m_rootElement->GetValue().ToStdString();
    docConfig.main_tree_attribute = m_mainTreeAttr->GetValue().ToStdString();
    docConfig.case_sensitive = m_caseSensitive->GetValue();
    docConfig.allow_unknown_elements = m_allowUnknownElements->GetValue();
    docConfig.whitespace_handling =
        static_cast<EmberCore::ParserConfig::WhitespaceHandling>(m_whitespaceHandling->GetSelection());
 
    // Get naming convention from checkboxes
    if (m_namingConventionStrict->GetValue()) {
        docConfig.naming_convention = EmberCore::ParserConfig::NamingConvention::STRICT;
    } else if (m_namingConventionBalanced->GetValue()) {
        docConfig.naming_convention = EmberCore::ParserConfig::NamingConvention::BALANCED;
    } else if (m_namingConventionLoose->GetValue()) {
        docConfig.naming_convention = EmberCore::ParserConfig::NamingConvention::LOOSE;
    } else {
        // Default to BALANCED if none is selected
        docConfig.naming_convention = EmberCore::ParserConfig::NamingConvention::BALANCED;
    }
 
    // Tab 2: Tree Elements
    auto &treeConfig = config->GetTreeConfig();
    treeConfig.behavior_tree_element = m_behaviorTreeElement->GetValue().ToStdString();
    treeConfig.tree_id_attribute = m_treeIdAttr->GetValue().ToStdString();
    treeConfig.allow_multiple_trees = m_allowMultipleTrees->GetValue();
    treeConfig.subtree_element = m_subtreeElement->GetValue().ToStdString();
    treeConfig.subtree_reference_attribute = m_subtreeRefAttr->GetValue().ToStdString();
    treeConfig.validate_tree_structure = m_validateStructure->GetValue();
    treeConfig.require_root_node = m_requireRootNode->GetValue();
 
    // Tab 3: Node Elements
    auto &nodeConfig = config->GetNodeConfig();
    nodeConfig.control_element = m_controlElement->GetValue().ToStdString();
    nodeConfig.action_element = m_actionElement->GetValue().ToStdString();
    nodeConfig.condition_element = m_conditionElement->GetValue().ToStdString();
    nodeConfig.decorator_element = m_decoratorElement->GetValue().ToStdString();
    nodeConfig.generic_node_element = m_genericNodeElement->GetValue().ToStdString();
    nodeConfig.node_id_attribute = m_nodeIdAttr->GetValue().ToStdString();
    nodeConfig.node_name_attribute = m_nodeNameAttr->GetValue().ToStdString();
    nodeConfig.node_type_attribute = m_nodeTypeAttr->GetValue().ToStdString();
    nodeConfig.allow_custom_attributes = m_allowCustomAttrs->GetValue();
 
    // Tab 4: Node Classification
    auto &classConfig = config->GetClassificationConfig();
    classConfig.strategy =
        static_cast<EmberCore::ParserConfig::ClassificationStrategy>(m_classificationStrategy->GetSelection());
 
    classConfig.control_types.clear();
    for (unsigned int i = 0; i < m_controlTypesList->GetCount(); i++) {
        classConfig.control_types.push_back(m_controlTypesList->GetString(i).ToStdString());
    }
 
    classConfig.decorator_types.clear();
    for (unsigned int i = 0; i < m_decoratorTypesList->GetCount(); i++) {
        classConfig.decorator_types.push_back(m_decoratorTypesList->GetString(i).ToStdString());
    }
 
    classConfig.action_types.clear();
    for (unsigned int i = 0; i < m_actionTypesList->GetCount(); i++) {
        classConfig.action_types.push_back(m_actionTypesList->GetString(i).ToStdString());
    }
 
    classConfig.condition_types.clear();
    for (unsigned int i = 0; i < m_conditionTypesList->GetCount(); i++) {
        classConfig.condition_types.push_back(m_conditionTypesList->GetString(i).ToStdString());
    }
 
    classConfig.unknown_behavior =
        static_cast<EmberCore::ParserConfig::UnknownTypeBehavior>(m_unknownBehavior->GetSelection());
    classConfig.type_attribute_name = m_typeAttrName->GetValue().ToStdString();
 
    // Tab 5: Blackboard
    auto &bbConfig = config->GetBlackboardConfig();
    bbConfig.blackboard_element = m_blackboardElement->GetValue().ToStdString();
    bbConfig.blackboard_id_attribute = m_blackboardIdAttr->GetValue().ToStdString();
    bbConfig.parent_attribute = m_blackboardParentAttr->GetValue().ToStdString();
    bbConfig.entry_element = m_entryElement->GetValue().ToStdString();
    bbConfig.entry_key_attribute = m_entryKeyAttr->GetValue().ToStdString();
    bbConfig.entry_type_attribute = m_entryTypeAttr->GetValue().ToStdString();
    bbConfig.entry_value_attribute = m_entryValueAttr->GetValue().ToStdString();
    bbConfig.allow_undefined_keys = m_allowUndefinedKeys->GetValue();
 
    bbConfig.type_mappings.clear();
    for (int i = 0; i < m_typeMappingsGrid->GetNumberRows(); i++) {
        EmberCore::String xmlType = m_typeMappingsGrid->GetCellValue(i, 0).ToStdString();
        EmberCore::String internalType = m_typeMappingsGrid->GetCellValue(i, 1).ToStdString();
        if (!xmlType.empty() && !internalType.empty()) {
            bbConfig.type_mappings[xmlType] = internalType;
        }
    }
 
    // Tab 6: Advanced
    auto &advConfig = config->GetAdvancedConfig();
    advConfig.enable_progress_reporting = m_enableProgressReporting->GetValue();
    advConfig.detailed_error_messages = m_detailedErrors->GetValue();
    advConfig.track_line_column = m_trackLineColumn->GetValue();
    advConfig.subtree_expansion =
        static_cast<EmberCore::ParserConfig::SubTreeExpansion>(m_subtreeExpansion->GetSelection());
    advConfig.max_recursion_depth = m_maxRecursionDepth->GetValue();
    advConfig.xml_namespace_uri = m_xmlNamespace->GetValue().ToStdString();
    advConfig.preserve_comments = m_preserveComments->GetValue();
    advConfig.preserve_attribute_order = m_preserveAttrOrder->GetValue();
 
    // Only save custom validation rules if the toggle is enabled
    if (m_enableCustomValidation->GetValue()) {
        advConfig.custom_validation_rules = m_customValidation->GetValue().ToStdString();
    } else {
        advConfig.custom_validation_rules = "";
    }
 
    return config;
}
 
bool ParserConfigDialog::ValidateCurrentConfig(wxString &errorMsg) {
    bool hasErrors = false;
    int errorCount = 0;
    wxString detailedErrors;
 
    // Helper lambda to add formatted error
    auto addError = [&](const wxString &page, const wxString &field, const wxString &issue) {
        errorCount++;
        detailedErrors += wxString::Format("%d. [Page: %s]\n"
                                           "   Field: %s\n"
                                           "   Issue: %s\n\n",
                                           errorCount, page, field, issue);
        hasErrors = true;
    };
 
    // ========================================================================
    // PAGE 1: DOCUMENT STRUCTURE
    // ========================================================================
 
    if (IsFieldEmpty(m_rootElement)) {
        addError("Document Structure", "Root Element",
                 "Required field is empty. Specify the XML root element name (e.g., 'root')");
    } else if (HasInvalidCharacters(m_rootElement)) {
        addError("Document Structure", "Root Element",
                 wxString::Format("Invalid characters detected. XML names must start with a letter or underscore, "
                                  "and can ONLY contain letters (a-z, A-Z) and underscores (_). "
                                  "NO digits, hyphens, periods, or special characters allowed. Current value: '%s'",
                                  m_rootElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_mainTreeAttr)) {
        addError("Document Structure", "Main Tree Attribute",
                 "Required field is empty. Specify the attribute that identifies the main tree");
    } else if (HasInvalidCharacters(m_mainTreeAttr)) {
        addError(
            "Document Structure", "Main Tree Attribute",
            wxString::Format("Invalid characters detected. Only letters and underscores allowed. Current value: '%s'",
                             m_mainTreeAttr->GetValue()));
    }
 
    // ========================================================================
    // PAGE 2: TREE ELEMENTS
    // ========================================================================
 
    if (IsFieldEmpty(m_behaviorTreeElement)) {
        addError("Tree Elements", "Behavior Tree Element",
                 "Required field is empty. Specify the element name for behavior trees (e.g., 'BehaviorTree')");
    } else if (HasInvalidCharacters(m_behaviorTreeElement)) {
        addError("Tree Elements", "Behavior Tree Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_behaviorTreeElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_treeIdAttr)) {
        addError("Tree Elements", "Tree ID Attribute",
                 "Required field is empty. Specify the attribute that holds tree IDs (e.g., 'ID' or 'name')");
    } else if (HasInvalidCharacters(m_treeIdAttr)) {
        addError("Tree Elements", "Tree ID Attribute",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_treeIdAttr->GetValue()));
    }
 
    if (IsFieldEmpty(m_subtreeElement)) {
        addError("Tree Elements", "SubTree Element",
                 "Required field is empty. Specify the element name for subtree references (e.g., 'SubTree')");
    } else if (HasInvalidCharacters(m_subtreeElement)) {
        addError("Tree Elements", "SubTree Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_subtreeElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_subtreeRefAttr)) {
        addError("Tree Elements", "SubTree Reference Attribute",
                 "Required field is empty. Specify the attribute that references other trees (e.g., 'ID')");
    } else if (HasInvalidCharacters(m_subtreeRefAttr)) {
        addError("Tree Elements", "SubTree Reference Attribute",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_subtreeRefAttr->GetValue()));
    }
 
    // ========================================================================
    // PAGE 3: NODE ELEMENTS
    // ========================================================================
 
    if (IsFieldEmpty(m_controlElement)) {
        addError("Node Elements", "Control Node Element",
                 "Required field is empty. Specify element name for control nodes (e.g., 'Control' or leave generic)");
    } else if (HasInvalidCharacters(m_controlElement)) {
        addError("Node Elements", "Control Node Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_controlElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_actionElement)) {
        addError("Node Elements", "Action Node Element",
                 "Required field is empty. Specify element name for action nodes (e.g., 'Action')");
    } else if (HasInvalidCharacters(m_actionElement)) {
        addError("Node Elements", "Action Node Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_actionElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_conditionElement)) {
        addError("Node Elements", "Condition Node Element",
                 "Required field is empty. Specify element name for condition nodes (e.g., 'Condition')");
    } else if (HasInvalidCharacters(m_conditionElement)) {
        addError("Node Elements", "Condition Node Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_conditionElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_decoratorElement)) {
        addError("Node Elements", "Decorator Node Element",
                 "Required field is empty. Specify element name for decorator nodes (e.g., 'Decorator')");
    } else if (HasInvalidCharacters(m_decoratorElement)) {
        addError("Node Elements", "Decorator Node Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_decoratorElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_nodeNameAttr)) {
        addError("Node Elements", "Node Name Attribute",
                 "Required field is empty. Specify the attribute for node names (e.g., 'name')");
    } else if (HasInvalidCharacters(m_nodeNameAttr)) {
        addError("Node Elements", "Node Name Attribute",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_nodeNameAttr->GetValue()));
    }
 
    // ========================================================================
    // PAGE 4: BLACKBOARD
    // ========================================================================
 
    if (IsFieldEmpty(m_blackboardElement)) {
        addError("Blackboard", "Blackboard Element",
                 "Required field is empty. Specify element name for blackboard (e.g., 'Blackboard')");
    } else if (HasInvalidCharacters(m_blackboardElement)) {
        addError("Blackboard", "Blackboard Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_blackboardElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_blackboardIdAttr)) {
        addError("Blackboard", "Blackboard ID Attribute",
                 "Required field is empty. Specify the attribute for blackboard IDs (e.g., 'ID')");
    } else if (HasInvalidCharacters(m_blackboardIdAttr)) {
        addError("Blackboard", "Blackboard ID Attribute",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_blackboardIdAttr->GetValue()));
    }
 
    if (IsFieldEmpty(m_entryElement)) {
        addError("Blackboard", "Entry Element",
                 "Required field is empty. Specify element name for blackboard entries (e.g., 'Entry')");
    } else if (HasInvalidCharacters(m_entryElement)) {
        addError("Blackboard", "Entry Element",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_entryElement->GetValue()));
    }
 
    if (IsFieldEmpty(m_entryKeyAttr)) {
        addError("Blackboard", "Entry Key Attribute",
                 "Required field is empty. Specify the attribute for entry keys (e.g., 'key')");
    } else if (HasInvalidCharacters(m_entryKeyAttr)) {
        addError("Blackboard", "Entry Key Attribute",
                 wxString::Format("Invalid characters. Only letters and underscores allowed. Current value: '%s'",
                                  m_entryKeyAttr->GetValue()));
    }
 
    // ========================================================================
    // PAGE 5: NODE CLASSIFICATION
    // ========================================================================
 
    // Strategy must be selected
    if (m_classificationStrategy && m_classificationStrategy->GetSelection() == wxNOT_FOUND) {
        addError("Node Classification", "Classification Strategy",
                 "No strategy selected. Choose: Element Name, Attribute-based, or Hybrid");
    }
 
    // Check if type lists are needed but empty
    if (m_classificationStrategy && (m_classificationStrategy->GetSelection() == 0 ||
                                     m_classificationStrategy->GetSelection() == 2)) { // Element Name or Hybrid
 
        if (m_controlTypesList && m_controlTypesList->GetCount() == 0) {
            addError("Node Classification", "Control Node Types List",
                     "Using Element Name classification but control types list is empty. Add control node types (e.g., "
                     "Sequence, Selector)");
        }
 
        if (m_actionTypesList && m_actionTypesList->GetCount() == 0) {
            addError("Node Classification", "Action Node Types List",
                     "Using Element Name classification but action types list is empty. Add action node types");
        }
 
        if (m_conditionTypesList && m_conditionTypesList->GetCount() == 0) {
            addError("Node Classification", "Condition Node Types List",
                     "Using Element Name classification but condition types list is empty. Add condition node types");
        }
 
        if (m_decoratorTypesList && m_decoratorTypesList->GetCount() == 0) {
            addError("Node Classification", "Decorator Node Types List",
                     "Using Element Name classification but decorator types list is empty. Add decorator node types");
        }
    }
 
    // Check type attribute if using attribute-based classification
    if (m_classificationStrategy && (m_classificationStrategy->GetSelection() == 1 ||
                                     m_classificationStrategy->GetSelection() == 2)) { // Attribute or Hybrid
 
        if (IsFieldEmpty(m_typeAttrName)) {
            addError("Node Classification", "Type Attribute Name",
                     "Using Attribute-based classification but type attribute is empty. Specify attribute name (e.g., "
                     "'type')");
        }
    }
 
    // ========================================================================
    // CROSS-PAGE VALIDATION
    // ========================================================================
 
    // Check for duplicate element names across pages
    wxString btElement = m_behaviorTreeElement ? m_behaviorTreeElement->GetValue().Trim() : "";
    wxString stElement = m_subtreeElement ? m_subtreeElement->GetValue().Trim() : "";
    wxString bbElement = m_blackboardElement ? m_blackboardElement->GetValue().Trim() : "";
 
    if (!btElement.IsEmpty() && btElement == stElement && btElement != "SubTree") {
        addError("Tree Elements", "Element Name Conflict",
                 wxString::Format("BehaviorTree and SubTree use same element name '%s'. They should be different",
                                  btElement));
    }
 
    if (!btElement.IsEmpty() && btElement == bbElement) {
        addError("Configuration Conflict", "Element Name Conflict",
                 wxString::Format("BehaviorTree and Blackboard use same element name '%s'. They should be different",
                                  btElement));
    }
 
    // ========================================================================
    // BUILD FINAL ERROR MESSAGE
    // ========================================================================
 
    if (hasErrors) {
        errorMsg = wxString::Format("VALIDATION FAILED - Found %d error(s)\n"
                                    "========================================\n\n"
                                    "%s"
                                    "Please fix these issues before saving the configuration.\n"
                                    "Tip: Empty required fields are highlighted with a pulsing yellow background.",
                                    errorCount, detailedErrors);
        return false;
    }
 
    // If UI validation passes, also run the config-level validation
    auto config = GetConfigFromUI();
    std::vector<EmberCore::String> configErrors;
 
    if (!config->Validate(configErrors)) {
        errorMsg = "ADDITIONAL VALIDATION ERRORS\n"
                   "========================================\n\n";
        for (const auto &err : configErrors) {
            errorMsg += wxString::Format("- %s\n", wxString(err));
        }
        return false;
    }
 
    return true;
}
 
void ParserConfigDialog::UpdateProfileList() { LoadProfiles(); }
 
void ParserConfigDialog::EnableProfileControls(bool enable) {
    m_notebook->Enable(enable);
    m_profileName->Enable(enable);
    m_profileDescription->Enable(enable);
    m_saveBtn->Enable(enable);
    m_saveAsBtn->Enable(enable);
}
 
wxString ParserConfigDialog::GetSelectedProfileName() const {
    long selectedIndex = m_profileList->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    if (selectedIndex == -1)
        return wxEmptyString;
    return m_profileList->GetItemText(selectedIndex);
}
 
// ============================================================================
// PULSE ANIMATION IMPLEMENTATION
// ============================================================================
 
ParserConfigDialog::~ParserConfigDialog() {
    if (m_pulseTimer) {
        m_pulseTimer->Stop();
        delete m_pulseTimer;
    }
}
 
void ParserConfigDialog::OnPulseTimer(wxTimerEvent &event) {
    // Increment phase (0.0 to 1.0, then wrap)
    m_pulsePhase += 0.02f; // Smooth increment
    if (m_pulsePhase > 1.0f) {
        m_pulsePhase = 0.0f;
    }
 
    UpdateFieldColors();
}
 
void ParserConfigDialog::UpdateFieldColors() {
    // Use sinusoidal easing for smooth, natural pulse
    // sin gives values from 0 to 1 to 0 smoothly
    float t = std::sin(m_pulsePhase * 3.14159f * 2.0f) * 0.5f + 0.5f;
 
    // List of all required text fields that should pulse when empty OR invalid
    wxTextCtrl *textFields[] = {m_rootElement,      m_mainTreeAttr,      m_behaviorTreeElement, m_treeIdAttr,
                                m_subtreeElement,   m_subtreeRefAttr,    m_controlElement,      m_actionElement,
                                m_conditionElement, m_decoratorElement,  m_nodeNameAttr,        m_nodeIdAttr,
                                m_nodeTypeAttr,     m_blackboardElement, m_blackboardIdAttr,    m_blackboardParentAttr,
                                m_entryElement,     m_entryKeyAttr,      m_entryTypeAttr,       m_entryValueAttr,
                                m_typeAttrName};
 
    // Update each text field
    for (wxTextCtrl *field : textFields) {
        if (field && (IsFieldEmpty(field) || HasInvalidCharacters(field))) {
            // Field is empty OR has invalid characters - pulse yellow
            wxColour pulseColor = InterpolateColor(m_normalBg, m_highlightBg, t);
            field->SetBackgroundColour(pulseColor);
            field->Refresh();
        } else if (field) {
            // Field has valid content, use normal background
            field->SetBackgroundColour(m_normalBg);
            field->Refresh();
        }
    }
}
 
wxColour ParserConfigDialog::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
    int r = static_cast<int>(color1.Red() + (color2.Red() - color1.Red()) * t);
    int g = static_cast<int>(color1.Green() + (color2.Green() - color1.Green()) * t);
    int b = static_cast<int>(color1.Blue() + (color2.Blue() - color1.Blue()) * t);
 
    return wxColour(r, g, b);
}
 
bool ParserConfigDialog::IsFieldEmpty(wxTextCtrl *field) {
    if (!field)
        return false;
    return field->GetValue().Trim().IsEmpty();
}
 
bool ParserConfigDialog::IsFieldEmpty(wxChoice *field) {
    if (!field)
        return false;
    return field->GetSelection() == wxNOT_FOUND;
}
 
bool ParserConfigDialog::HasInvalidCharacters(wxTextCtrl *field) {
    if (!field)
        return false;
 
    wxString value = field->GetValue().Trim();
    if (value.IsEmpty())
        return false; // Empty is handled separately
 
    // Use current naming convention for validation
    return !IsValidXMLName(value, GetCurrentNamingConvention());
}
 
EmberCore::ParserConfig::NamingConvention ParserConfigDialog::GetCurrentNamingConvention() const {
    if (m_namingConventionStrict && m_namingConventionStrict->GetValue()) {
        return EmberCore::ParserConfig::NamingConvention::STRICT;
    } else if (m_namingConventionLoose && m_namingConventionLoose->GetValue()) {
        return EmberCore::ParserConfig::NamingConvention::LOOSE;
    } else {
        // Default to BALANCED (including when m_namingConventionBalanced is checked)
        return EmberCore::ParserConfig::NamingConvention::BALANCED;
    }
}
 
bool ParserConfigDialog::IsValidXMLName(const wxString &name) {
    // Use current naming convention
    return IsValidXMLName(name, GetCurrentNamingConvention());
}
 
bool ParserConfigDialog::IsValidXMLName(const wxString &name, EmberCore::ParserConfig::NamingConvention convention) {
    if (name.IsEmpty())
        return true; // Empty is valid here (checked separately)
 
    switch (convention) {
    case EmberCore::ParserConfig::NamingConvention::STRICT:
        // STRICT: Only letters (a-z, A-Z) and underscores (_)
        // - Must start with a letter or underscore
        // - Can ONLY contain letters and underscores
        // - NO digits, hyphens, or any other characters
        {
            wxChar firstChar = name[0];
            if (!wxIsalpha(firstChar) && firstChar != '_') {
                return false;
            }
 
            for (size_t i = 0; i < name.Length(); i++) {
                wxChar c = name[i];
                if (!wxIsalpha(c) && c != '_') {
                    return false;
                }
            }
            return true;
        }
 
    case EmberCore::ParserConfig::NamingConvention::BALANCED:
        // BALANCED: Letters, underscores, digits, and hyphens
        // - Must start with a letter or underscore
        // - Can contain letters, digits, underscores, and hyphens
        {
            wxChar firstChar = name[0];
            if (!wxIsalpha(firstChar) && firstChar != '_') {
                return false;
            }
 
            for (size_t i = 0; i < name.Length(); i++) {
                wxChar c = name[i];
                if (!wxIsalpha(c) && !wxIsdigit(c) && c != '_' && c != '-') {
                    return false;
                }
            }
            return true;
        }
 
    case EmberCore::ParserConfig::NamingConvention::LOOSE:
        // LOOSE: Follow XML 1.0 name rules (most permissive)
        // - Must start with letter, underscore, or colon
        // - Can contain letters, digits, underscores, hyphens, periods, colons
        // - Avoid only problematic characters like <, >, &, quotes, spaces
        {
            wxChar firstChar = name[0];
            // XML names can start with: letter, underscore, or colon
            if (!wxIsalpha(firstChar) && firstChar != '_' && firstChar != ':') {
                return false;
            }
 
            for (size_t i = 0; i < name.Length(); i++) {
                wxChar c = name[i];
 
                // Reject XML-breaking characters
                if (c == '<' || c == '>' || c == '&' || c == '"' || c == '\'' || wxIsspace(c) || c == '/' ||
                    c == '\\' || c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || c == '}' || c == '=' ||
                    c == '!' || c == '?' || c == '*' || c == '+' || c == '#' || c == '@' || c == '$' || c == '%' ||
                    c == '^' || c == '~' || c == '`' || c == '|' || c == ';' || c == ',' ||
                    c < 32) { // Also reject control characters
                    return false;
                }
            }
            return true;
        }
 
    default:
        return false;
    }
}
 
void ParserConfigDialog::OnFieldChanged(wxCommandEvent &event) {
    // When a field changes, immediately update its color
    // (This ensures instant feedback when user starts typing)
    UpdateFieldColors();
    m_modified = true; // Mark profile as modified
    event.Skip();
}
 
void ParserConfigDialog::OnAnyControlChanged(wxCommandEvent &event) {
    // Generic handler for checkboxes, choice controls, etc.
    m_modified = true;
    event.Skip();
}
 
void ParserConfigDialog::OnNamingConventionChanged(wxCommandEvent &event) {
    // When naming convention changes, re-validate all fields with new rules
    // This will highlight fields that are now invalid under the new convention
    UpdateFieldColors();
    m_modified = true;
    event.Skip();
}