MainFrame.cpp

Go to the documentation of this file.

#include "App/MainFrame.h"
#include "Adapters/DirectTreeAdapter.h"        // NEW: Include DirectTreeAdapter
#include "Adapters/NodeAdapter.h"              // NEW: Include adapter for abstraction compatibility
#include "Components/TabFactory.h"             // Tab factory for creating tabs
#include "Core/BehaviorTree.h"                 // BehaviorTree class for tree storage
#include "Core/BehaviorTreeValidator.h"        // NEW: Include unified validator
#include "Dialogs/BehaviorTreeProjectDialog.h" // Project creation/editing dialog
#include "Dialogs/LoadingDialog.h"             // NEW: Include LoadingDialog for detailed loading window
#include "Dialogs/OverrideSceneDialog.h"       // NEW: Include custom override scene dialog
#include "Dialogs/ParserConfigDialog.h"        // Parser configuration dialog
#include "Dialogs/PreferencesDialog.h"         // NEW: Include preferences dialog
#include "Dialogs/ProjectManagerDialog.h"      // Project opening dialog
#include "Panels/BottomPanel.h"
#include "Panels/LeftSidePanel.h"
#include "Panels/MainPanel.h"
#include "Panels/RightSidePanel.h"
#include "Parsers/BehaviorTreeProject.h"          // BehaviorTree project class
#include "Parsers/ConfigManager.h"                // NEW: Include ConfigManager for parser profiles
#include "Parsers/LibXMLBehaviorTreeParser.h"     // Include libxml2 parser
#include "Parsers/LibXMLBehaviorTreeSerializer.h" // NEW: Include libxml2 serializer
#include "Parsers/ProjectManager.h"               // Project manager singleton
#include "Scenes/BehaviorTreeScene.h"
#include "Scenes/BlackboardScene.h"
#include "Tabs/FileExplorerTab.h"
#include "Tabs/ForgeNavigatorTab.h"
#include "Tabs/PropertiesTab.h"
#include "Utils/AppPreferences.h"     // NEW: Include application preferences system
#include "Utils/BehaviorTreeConfig.h" // NEW: Include configuration system
#include "Utils/CustomAuiNotebook.h"  // CustomAuiNotebook for panel notebooks
#include "Utils/DPI.h"
#include "Utils/Logger.h"             // NEW: Include unified logging system
#include "Utils/PerformanceMonitor.h" // NEW: Include performance monitoring
#include "Utils/ResourcePath.h"       // Centralized resource path management
#include <chrono>
#include <ctime>
#include <fstream>
#include <wx/artprov.h> // Include for wxArtProvider
#include <wx/aui/aui.h>
#include <wx/filename.h> // NEW: Include wxFileName for file operations
#include <wx/splitter.h>
#include <wx/stdpaths.h> // NEW: Include wxStandardPaths for getting executable directory
#include <wx/tglbtn.h>   // Include for wxToggleButton
 
wxBEGIN_EVENT_TABLE(MainFrame, wxFrame) EVT_MENU(wxID_EXIT, MainFrame::OnExit) EVT_MENU(wxID_ABOUT, MainFrame::OnAbout)
    EVT_MENU(ID_LoadXML, MainFrame::OnLoadXML)     // Event for XML loading (libxml2)
    EVT_MENU(ID_SaveXML, MainFrame::OnSaveXML)     // Event for XML saving
    EVT_MENU(ID_SaveAsXML, MainFrame::OnSaveAsXML) // Event for XML save as
    EVT_MENU(ID_ResetZoom, MainFrame::OnResetZoom) // Event for reset zoom hotkey
 
    // Project menu events
    EVT_MENU(ID_NewProject, MainFrame::OnNewProject) EVT_MENU(ID_OpenProject, MainFrame::OnOpenProject)
        EVT_MENU(ID_CloseProject, MainFrame::OnCloseProject) EVT_MENU(ID_SaveProject, MainFrame::OnSaveProject)
            EVT_MENU(ID_ProjectSettings, MainFrame::OnProjectSettings)
 
    // View menu events
    EVT_MENU(ID_ToggleMaximize, MainFrame::OnToggleMaximize) EVT_MENU(ID_NextScene, MainFrame::OnNextScene)
        EVT_MENU(ID_PreviousScene, MainFrame::OnPreviousScene) EVT_MENU(ID_ResetUI, MainFrame::OnResetUI)
 
    // Settings menu events
    EVT_MENU(ID_Preferences, MainFrame::OnPreferences) EVT_MENU(ID_ParserConfig, MainFrame::OnParserConfig)
 
    // Updated tool button events for new 3-button layout
    EVT_BUTTON(ID_EditorTool, MainFrame::OnEditorTool) EVT_BUTTON(ID_MonitorTool, MainFrame::OnMonitorTool)
        EVT_BUTTON(ID_LogReplayTool, MainFrame::OnLogReplayTool)
 
    // Panel toggle events
    EVT_BUTTON(ID_ToggleLeftPanel, MainFrame::OnToggleLeftPanel)
        EVT_BUTTON(ID_ToggleBottomPanel, MainFrame::OnToggleBottomPanel)
            EVT_BUTTON(ID_ToggleRightPanel, MainFrame::OnToggleRightPanel)
 
    // Performance monitoring events
    EVT_PAINT(MainFrame::OnPaint) EVT_IDLE(MainFrame::OnIdle) EVT_SIZE(MainFrame::OnFrameResize) wxEND_EVENT_TABLE()
 
        MainFrame::MainFrame(const wxString &title, const wxPoint &pos, const wxSize &size, long style)
    : wxFrame(NULL, wxID_ANY, title, pos, size, style), m_auiManager(nullptr), m_bottomPanel(nullptr),
      m_scenePanel(nullptr), m_panelToggleToolbar(nullptr) {
    // Initialize unified AUI manager
    m_auiManager = new wxAuiManager(this);
 
    // Increase sash size for easier resizing
    m_auiManager->GetArtProvider()->SetMetric(wxAUI_DOCKART_SASH_SIZE, 8);
 
    LOG_INFO("AUI", "Initialized unified AUI manager for MainFrame");
 
    // Load application preferences
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    EmberCore::String configPath = EmberForge::AppPreferences::GetDefaultConfigPath();
    if (prefs.LoadFromFile(configPath)) {
        LOG_INFO("Preferences", "Application preferences loaded from: " + configPath);
    } else {
        LOG_INFO("Preferences", "Using default preferences (config file not found or invalid)");
    }
 
    CreateMenuAndStatusBar();
    CreatePanelToggleToolbar();
    InitializeConfigurationMenu();
    CreatePanelLayout();
 
    // Apply window startup mode preferences
    const auto &windowSettings = prefs.GetWindowSettings();
 
    // Apply status bar visibility preference
    if (windowSettings.showStatusBar) {
        GetStatusBar()->Show();
        LOG_INFO("Preferences", "Status bar enabled");
    } else {
        GetStatusBar()->Hide();
        LOG_INFO("Preferences", "Status bar hidden");
    }
    switch (windowSettings.startupMode) {
    case EmberForge::AppPreferences::StartupMode::Maximized:
        // Maximize window but keep menu bar and title bar visible
        Maximize(true);
        LOG_INFO("Preferences", "Starting in maximized mode");
        break;
    case EmberForge::AppPreferences::StartupMode::Normal:
    default:
        LOG_INFO("Preferences", "Starting in normal windowed mode");
        break;
    }
 
    // Apply window appearance settings
    if (windowSettings.alwaysOnTop) {
        SetWindowStyle(GetWindowStyle() | wxSTAY_ON_TOP);
        LOG_INFO("Preferences", "Window set to always on top");
    }
 
    // Apply window size constraints (percentage of screen)
    wxSize screen = EmberUI::DPI::GetScreenSize(this);
    int minW = screen.x * windowSettings.minWindowWidthPct / 100;
    int minH = screen.y * windowSettings.minWindowHeightPct / 100;
    SetMinSize(wxSize(minW, minH));
    LOG_INFO("Preferences", "Minimum window size set to " + std::to_string(minW) + "x" + std::to_string(minH) + " (" +
                                std::to_string(windowSettings.minWindowWidthPct) + "% x " +
                                std::to_string(windowSettings.minWindowHeightPct) + "% of screen)");
 
    if (windowSettings.maxWindowWidthPct > 0 && windowSettings.maxWindowHeightPct > 0) {
        int maxW = screen.x * windowSettings.maxWindowWidthPct / 100;
        int maxH = screen.y * windowSettings.maxWindowHeightPct / 100;
        SetMaxSize(wxSize(maxW, maxH));
        LOG_INFO("Preferences", "Maximum window size set to " + std::to_string(maxW) + "x" + std::to_string(maxH) +
                                    " (" + std::to_string(windowSettings.maxWindowWidthPct) + "% x " +
                                    std::to_string(windowSettings.maxWindowHeightPct) + "% of screen)");
    }
 
    // Apply aspect ratio constraint (if enabled)
    if (windowSettings.enforceAspectRatio) {
        // Note: wxWidgets doesn't have built-in aspect ratio enforcement
        // This would require custom resize handling in EVT_SIZE
        LOG_INFO("Preferences", "Aspect ratio enforcement requested: " + std::to_string(windowSettings.aspectRatio) +
                                    " (requires custom implementation)");
    }
 
    // Apply Main Panel settings on startup
    const auto &mainPanelSettings = prefs.GetMainPanelSettings();
    if (m_scenePanel) {
        // Apply canvas background color
        wxColour bgColor(mainPanelSettings.canvasBackgroundColor.r, mainPanelSettings.canvasBackgroundColor.g,
                         mainPanelSettings.canvasBackgroundColor.b);
        m_scenePanel->ApplyCanvasBackgroundColor(bgColor);
 
        LOG_INFO("Preferences", "Main Panel settings applied on startup");
    }
 
    // Initialize performance monitoring
    EmberForge::PerformanceMonitor &monitor = EmberForge::PerformanceMonitor::GetInstance();
    monitor.SetEnabled(true);
    LOG_INFO("Performance", "Performance monitoring initialized in MainFrame");
 
    // Auto-load last opened file if enabled in preferences
    const auto &parserSettings = prefs.GetParserSettings();
    if (parserSettings.autoLoadLastFile && !parserSettings.lastOpenedFilePath.empty()) {
        wxString lastFilePath = wxString::FromUTF8(parserSettings.lastOpenedFilePath);
        if (wxFileExists(lastFilePath)) {
            LOG_INFO("Preferences", "Auto-loading last opened file: " + parserSettings.lastOpenedFilePath);
            CallAfter([this, lastFilePath]() { LoadXMLFile(lastFilePath, false); });
        } else {
            LOG_WARNING("Preferences", "Last opened file no longer exists: " + parserSettings.lastOpenedFilePath);
        }
    }
 
    // Set up welcome screen callback
    if (m_scenePanel) {
        m_scenePanel->SetWelcomeActionCallback([this](const std::string &action, const std::string &param) {
            if (action == "new_project") {
                NewProject();
            } else if (action == "open_project") {
                OpenProject();
            } else if (action == "open_recent") {
                OpenProject(wxString::FromUTF8(param));
            } else if (action == "docs") {
                wxLaunchDefaultBrowser("https://cloudflare-docs.ember-docs.pages.dev/");
            }
        });
    }
}
 
MainFrame::~MainFrame() {
    // Save panel states before cleanup
    if (m_leftPanel) {
        m_leftPanel->SaveState();
        LOG_INFO("MainFrame", "Saved left panel state");
    }
 
    if (m_rightPanel) {
        m_rightPanel->SaveState();
        LOG_INFO("MainFrame", "Saved right panel state");
    }
 
    if (m_bottomPanel) {
        m_bottomPanel->SaveState();
        LOG_INFO("MainFrame", "Saved bottom panel state");
    }
 
    // Save panel visibility states for "RememberLast" option
    if (m_auiManager) {
        auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
 
        // Save individual panel visibility
        wxAuiPaneInfo &leftPaneInfo = m_auiManager->GetPane("left_panel");
        wxAuiPaneInfo &rightPaneInfo = m_auiManager->GetPane("right_panel");
        wxAuiPaneInfo &bottomPaneInfo = m_auiManager->GetPane("bottom_panel");
 
        auto &leftSettings = prefs.GetLeftPanelSettings();
        auto &rightSettings = prefs.GetRightPanelSettings();
        auto &bottomSettings = prefs.GetBottomPanelSettings();
 
        leftSettings.lastPanelVisible = leftPaneInfo.IsShown();
        rightSettings.lastPanelVisible = rightPaneInfo.IsShown();
        bottomSettings.lastPanelVisible = bottomPaneInfo.IsShown();
 
        LOG_INFO("MainFrame", wxString::Format("Saved panel visibility - left: %d, right: %d, bottom: %d",
                                               leftSettings.lastPanelVisible, rightSettings.lastPanelVisible,
                                               bottomSettings.lastPanelVisible)
                                  .ToStdString());
    }
 
    // Save preferences to disk
    auto &prefManager = EmberForge::AppPreferencesManager::GetInstance();
    std::string configPath = EmberForge::AppPreferences::GetDefaultConfigPath();
    if (prefManager.GetPreferences().SaveToFile(configPath)) {
        LOG_INFO("MainFrame", "Saved preferences to disk: " + configPath);
    } else {
        LOG_ERROR("MainFrame", "Failed to save preferences to disk");
    }
 
    // Clean up unified AUI manager
    if (m_auiManager) {
        m_auiManager->UnInit();
        delete m_auiManager;
        m_auiManager = nullptr;
        LOG_INFO("AUI", "Cleaned up unified AUI manager");
    }
}
 
void MainFrame::CreateMenuAndStatusBar() {
    // Get hotkey settings from preferences
    auto &prefsMgr = EmberForge::AppPreferencesManager::GetInstance();
    auto &prefs = prefsMgr.GetPreferences();
    const auto &windowSettings = prefs.GetWindowSettings();
    const auto &mainPanelSettings = prefs.GetMainPanelSettings();
    const auto &btViewSettings = prefs.GetBehaviorTreeViewSettings();
 
    // Create menu bar
    wxMenu *menuFile = new wxMenu;
 
    // Project operations (at the top) with configured hotkeys
    wxString newProjectLabel = wxString::Format("New &Project...\t%s", windowSettings.newProjectHotkey);
    menuFile->Append(ID_NewProject, newProjectLabel, "Create a new BehaviorTree project");
 
    wxString openProjectLabel = wxString::Format("Open Pro&ject...\t%s", windowSettings.openProjectHotkey);
    menuFile->Append(ID_OpenProject, openProjectLabel, "Open an existing BehaviorTree project");
 
    menuFile->Append(ID_CloseProject, "&Close Project", "Close the current project");
    menuFile->Append(ID_SaveProject, "Save Project", "Save the current project");
    menuFile->Append(ID_ProjectSettings, "Project Settings...", "Edit project settings");
    menuFile->AppendSeparator();
 
    // Single file operations with configured hotkeys
    wxString openFileLabel = wxString::Format("&Open XML File...\t%s", windowSettings.openFileHotkey);
    menuFile->Append(ID_LoadXML, openFileLabel, "Load a behavior tree from XML file");
    menuFile->AppendSeparator();
 
    wxString saveLabel = wxString::Format("&Save\t%s", windowSettings.saveHotkey);
    menuFile->Append(ID_SaveXML, saveLabel, "Save current behavior tree to XML file");
 
    wxString saveAsLabel = wxString::Format("Save &As...\t%s", windowSettings.saveAsHotkey);
    menuFile->Append(ID_SaveAsXML, saveAsLabel, "Save behavior tree to new XML file");
    menuFile->AppendSeparator();
    menuFile->Append(wxID_EXIT);
 
    wxMenu *menuHelp = new wxMenu;
    menuHelp->Append(wxID_ABOUT);
 
    // Create View menu with configured hotkeys
    wxMenu *menuView = new wxMenu;
 
    wxString maximizeLabel = wxString::Format("&Maximize\t%s", windowSettings.maximizeHotkey);
    menuView->Append(ID_ToggleMaximize, maximizeLabel, "Toggle maximize window");
 
    menuView->AppendSeparator();
 
    // Scene navigation with configured hotkeys
    wxString nextSceneLabel = wxString::Format("&Next Scene\t%s", mainPanelSettings.nextSceneHotkey);
    menuView->Append(ID_NextScene, nextSceneLabel, "Switch to next scene");
 
    wxString prevSceneLabel = wxString::Format("&Previous Scene\t%s", mainPanelSettings.previousSceneHotkey);
    menuView->Append(ID_PreviousScene, prevSceneLabel, "Switch to previous scene");
 
    menuView->AppendSeparator();
 
    // Reset view control with configured hotkey
    wxString resetViewLabel = wxString::Format("&Reset View\t%s", btViewSettings.resetViewHotkey);
    menuView->Append(ID_ResetZoom, resetViewLabel, "Reset zoom and pan to default");
 
    menuView->AppendSeparator();
 
    // Reset UI option with configured hotkey
    wxString resetUILabel = wxString::Format("Reset &UI\t%s", windowSettings.resetUIHotkey);
    menuView->Append(ID_ResetUI, resetUILabel, "Reset all panels and preferences to defaults");
 
    // Create Settings menu with configured hotkeys
    wxMenu *menuSettings = new wxMenu;
 
    wxString preferencesLabel = wxString::Format("&Preferences...\t%s", windowSettings.preferencesHotkey);
    menuSettings->Append(ID_Preferences, preferencesLabel,
                         "Open the preferences dialog to configure EmberForge settings");
 
    wxString parserConfigLabel = wxString::Format("&Parser Configuration...\t%s", windowSettings.parserConfigHotkey);
    menuSettings->Append(ID_ParserConfig, parserConfigLabel,
                         "Configure XML parser behavior and create custom profiles");
 
    wxMenuBar *menuBar = new wxMenuBar;
    menuBar->Append(menuFile, "&File");
    menuBar->Append(menuView, "&View");         // Add View menu
    menuBar->Append(menuSettings, "&Settings"); // NEW: Add Settings menu
    menuBar->Append(menuHelp, "&Help");
 
    SetMenuBar(menuBar);
 
    // Create status bar
    CreateStatusBar();
    SetStatusText("Welcome to EmberForge!");
}
 
void MainFrame::CreatePanelToggleToolbar() {
    // Create toolbar at the top
    m_panelToggleToolbar = CreateToolBar(wxTB_FLAT | wxTB_HORIZONTAL | wxTB_NODIVIDER, wxID_ANY);
    m_panelToggleToolbar->SetToolBitmapSize(wxSize(22, 22));
 
    // Note: Tree selector is now embedded in the BehaviorTreeScene canvas (top-right corner)
 
    // Add a stretchable spacer to push buttons to the right
    m_panelToggleToolbar->AddStretchableSpace();
 
    // Load custom icons from resources folder
    wxString resourcePath = EmberForge::ResourcePath::GetDir("buttons");
 
    // Left panel button with all states
    wxBitmap leftNormal(resourcePath + "left_panel/Left_Panel_Normal_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap leftHovered(resourcePath + "left_panel/Left_Panel_Hovered_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap leftPressed(resourcePath + "left_panel/Left_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap leftDisabled(resourcePath + "left_panel/Left_Panel_Disabled_22.png", wxBITMAP_TYPE_PNG);
 
    wxBitmapButton *leftBtn = new wxBitmapButton(m_panelToggleToolbar, ID_ToggleLeftPanel, leftNormal,
                                                 wxDefaultPosition, wxSize(32, 32), wxBORDER_NONE | wxBU_EXACTFIT);
    leftBtn->SetBitmapHover(leftHovered);
    leftBtn->SetBitmapPressed(leftPressed);
    leftBtn->SetBitmapDisabled(leftDisabled);
    leftBtn->SetToolTip("Toggle Left Panel");
    m_panelToggleToolbar->AddControl(leftBtn);
 
    // Bottom panel button with all states
    wxBitmap bottomNormal(resourcePath + "bottom_panel/Bottom_Panel_Normal_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap bottomHovered(resourcePath + "bottom_panel/Bottom_Panel_Hovered_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap bottomPressed(resourcePath + "bottom_panel/Bottom_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap bottomDisabled(resourcePath + "bottom_panel/Bottom_Panel_Disabled_22.png", wxBITMAP_TYPE_PNG);
 
    wxBitmapButton *bottomBtn = new wxBitmapButton(m_panelToggleToolbar, ID_ToggleBottomPanel, bottomNormal,
                                                   wxDefaultPosition, wxSize(32, 32), wxBORDER_NONE | wxBU_EXACTFIT);
    bottomBtn->SetBitmapHover(bottomHovered);
    bottomBtn->SetBitmapPressed(bottomPressed);
    bottomBtn->SetBitmapDisabled(bottomDisabled);
    bottomBtn->SetToolTip("Toggle Bottom Panel");
    m_panelToggleToolbar->AddControl(bottomBtn);
 
    // Right panel button with all states
    wxBitmap rightNormal(resourcePath + "right_panel/Right_Panel_Normal_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap rightHovered(resourcePath + "right_panel/Right_Panel_Hovered_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap rightPressed(resourcePath + "right_panel/Right_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG);
    wxBitmap rightDisabled(resourcePath + "right_panel/Right_Panel_Disabled_22.png", wxBITMAP_TYPE_PNG);
 
    wxBitmapButton *rightBtn = new wxBitmapButton(m_panelToggleToolbar, ID_ToggleRightPanel, rightNormal,
                                                  wxDefaultPosition, wxSize(32, 32), wxBORDER_NONE | wxBU_EXACTFIT);
    rightBtn->SetBitmapHover(rightHovered);
    rightBtn->SetBitmapPressed(rightPressed);
    rightBtn->SetBitmapDisabled(rightDisabled);
    rightBtn->SetToolTip("Toggle Right Panel");
    m_panelToggleToolbar->AddControl(rightBtn);
 
    m_panelToggleToolbar->Realize();
 
    LOG_INFO("UI", "Panel toggle toolbar created with state-aware custom icons");
}
 
void MainFrame::InitializeConfigurationMenu() {
    // No menu initialization needed for preferences dialog approach
    LOG_INFO("Config", "Configuration system initialized - use Settings > Preferences to configure");
}
 
void MainFrame::RefreshMenuHotkeys() {
    // Get updated hotkey settings from preferences
    auto &prefsMgr = EmberForge::AppPreferencesManager::GetInstance();
    auto &prefs = prefsMgr.GetPreferences();
    const auto &windowSettings = prefs.GetWindowSettings();
    const auto &mainPanelSettings = prefs.GetMainPanelSettings();
    const auto &btViewSettings = prefs.GetBehaviorTreeViewSettings();
 
    wxMenuBar *menuBar = GetMenuBar();
    if (!menuBar)
        return;
 
    // Update File menu hotkeys
    int fileMenuIndex = menuBar->FindMenu("File");
    if (fileMenuIndex != wxNOT_FOUND) {
        wxMenu *menuFile = menuBar->GetMenu(fileMenuIndex);
        if (menuFile) {
            wxMenuItem *newProjectItem = menuFile->FindItem(ID_NewProject);
            if (newProjectItem) {
                newProjectItem->SetItemLabel(wxString::Format("New &Project...\t%s", windowSettings.newProjectHotkey));
            }
 
            wxMenuItem *openProjectItem = menuFile->FindItem(ID_OpenProject);
            if (openProjectItem) {
                openProjectItem->SetItemLabel(
                    wxString::Format("Open Pro&ject...\t%s", windowSettings.openProjectHotkey));
            }
 
            wxMenuItem *openFileItem = menuFile->FindItem(ID_LoadXML);
            if (openFileItem) {
                openFileItem->SetItemLabel(wxString::Format("&Open XML File...\t%s", windowSettings.openFileHotkey));
            }
 
            wxMenuItem *saveItem = menuFile->FindItem(ID_SaveXML);
            if (saveItem) {
                saveItem->SetItemLabel(wxString::Format("&Save\t%s", windowSettings.saveHotkey));
            }
 
            wxMenuItem *saveAsItem = menuFile->FindItem(ID_SaveAsXML);
            if (saveAsItem) {
                saveAsItem->SetItemLabel(wxString::Format("Save &As...\t%s", windowSettings.saveAsHotkey));
            }
        }
    }
 
    // Update View menu hotkeys
    int viewMenuIndex = menuBar->FindMenu("View");
    if (viewMenuIndex != wxNOT_FOUND) {
        wxMenu *menuView = menuBar->GetMenu(viewMenuIndex);
        if (menuView) {
            wxMenuItem *maximizeItem = menuView->FindItem(ID_ToggleMaximize);
            if (maximizeItem) {
                maximizeItem->SetItemLabel(wxString::Format("&Maximize\t%s", windowSettings.maximizeHotkey));
            }
 
            wxMenuItem *nextSceneItem = menuView->FindItem(ID_NextScene);
            if (nextSceneItem) {
                nextSceneItem->SetItemLabel(wxString::Format("&Next Scene\t%s", mainPanelSettings.nextSceneHotkey));
            }
 
            wxMenuItem *prevSceneItem = menuView->FindItem(ID_PreviousScene);
            if (prevSceneItem) {
                prevSceneItem->SetItemLabel(
                    wxString::Format("&Previous Scene\t%s", mainPanelSettings.previousSceneHotkey));
            }
 
            wxMenuItem *resetViewItem = menuView->FindItem(ID_ResetZoom);
            if (resetViewItem) {
                resetViewItem->SetItemLabel(wxString::Format("&Reset View\t%s", btViewSettings.resetViewHotkey));
            }
 
            wxMenuItem *resetUIItem = menuView->FindItem(ID_ResetUI);
            if (resetUIItem) {
                resetUIItem->SetItemLabel(wxString::Format("Reset &UI\t%s", windowSettings.resetUIHotkey));
            }
        }
    }
 
    // Update Settings menu hotkeys
    int settingsMenuIndex = menuBar->FindMenu("Settings");
    if (settingsMenuIndex != wxNOT_FOUND) {
        wxMenu *menuSettings = menuBar->GetMenu(settingsMenuIndex);
        if (menuSettings) {
            wxMenuItem *preferencesItem = menuSettings->FindItem(ID_Preferences);
            if (preferencesItem) {
                preferencesItem->SetItemLabel(
                    wxString::Format("&Preferences...\t%s", windowSettings.preferencesHotkey));
            }
 
            wxMenuItem *parserConfigItem = menuSettings->FindItem(ID_ParserConfig);
            if (parserConfigItem) {
                parserConfigItem->SetItemLabel(
                    wxString::Format("&Parser Configuration...\t%s", windowSettings.parserConfigHotkey));
            }
        }
    }
 
    LOG_INFO("Preferences", "Menu hotkeys refreshed");
}
 
void MainFrame::RefreshCanvasVisualization() {
    // Refresh the canvas visualization to show tree structure changes
    if (!m_scenePanel)
        return;
 
    auto activeScene = m_scenePanel->GetActiveScene();
    if (!activeScene || activeScene->GetSceneType() != "BehaviorTree")
        return;
 
    auto *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
    if (!btScene)
        return;
 
    auto *treeVis = btScene->GetTreeVisualization();
    if (treeVis) {
        auto currentTree = treeVis->GetTree();
        if (currentTree) {
            treeVis->SetTree(currentTree);
        }
 
        treeVis->RefreshCanvas();
        treeVis->Refresh();
        treeVis->Update();
    }
 
    btScene->Refresh();
    m_scenePanel->Refresh();
    m_scenePanel->Update();
}
 
void MainFrame::RefreshPreferences() {
    // Refresh menu hotkeys
    RefreshMenuHotkeys();
 
    // Apply preferences
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &windowSettings = prefs.GetWindowSettings();
 
    // Apply status bar visibility
    if (windowSettings.showStatusBar) {
        GetStatusBar()->Show();
    } else {
        GetStatusBar()->Hide();
    }
 
    // Apply panel caption visibility
    if (m_auiManager) {
        wxAuiPaneInfo &leftPane = m_auiManager->GetPane("left_panel");
        if (leftPane.IsOk()) {
            leftPane.CaptionVisible(windowSettings.showPanelCaptions);
        }
 
        wxAuiPaneInfo &rightPane = m_auiManager->GetPane("right_panel");
        if (rightPane.IsOk()) {
            rightPane.CaptionVisible(windowSettings.showPanelCaptions);
        }
 
        wxAuiPaneInfo &bottomPane = m_auiManager->GetPane("bottom_panel");
        if (bottomPane.IsOk()) {
            bottomPane.CaptionVisible(windowSettings.showPanelCaptions);
        }
 
        wxAuiPaneInfo &scenePane = m_auiManager->GetPane("scene_panel");
        if (scenePane.IsOk()) {
            scenePane.CaptionVisible(windowSettings.showPanelCaptions);
        }
 
        m_auiManager->Update();
        LOG_INFO("Preferences",
                 std::string("Panel captions ") + (windowSettings.showPanelCaptions ? "shown" : "hidden"));
    }
 
    // Apply always on top
    long currentStyle = GetWindowStyle();
    bool styleChanged = false;
 
    if (windowSettings.alwaysOnTop) {
        if (!(currentStyle & wxSTAY_ON_TOP)) {
            SetWindowStyle(currentStyle | wxSTAY_ON_TOP);
            LOG_INFO("Preferences", "Window set to always on top");
            styleChanged = true;
        }
    } else {
        if (currentStyle & wxSTAY_ON_TOP) {
            SetWindowStyle(currentStyle & ~wxSTAY_ON_TOP);
            LOG_INFO("Preferences", "Window always on top disabled");
            styleChanged = true;
        }
    }
 
    // If style changed, force a proper refresh
    if (styleChanged) {
        // Ensure menu bar accelerators are preserved
        wxMenuBar *menuBar = GetMenuBar();
        if (menuBar) {
            // Detach and reattach menu bar to ensure accelerators work
            SetMenuBar(nullptr);
            SetMenuBar(menuBar);
        }
        Update();
    }
 
    // Apply Main Panel settings
    const auto &mainPanelSettings = prefs.GetMainPanelSettings();
    if (m_scenePanel) {
        // Apply canvas background color
        wxColour bgColor(mainPanelSettings.canvasBackgroundColor.r, mainPanelSettings.canvasBackgroundColor.g,
                         mainPanelSettings.canvasBackgroundColor.b);
        m_scenePanel->ApplyCanvasBackgroundColor(bgColor);
 
        // Reload zoom/pan preferences for all scenes
        int sceneCount = m_scenePanel->GetSceneCount();
        for (int i = 0; i < sceneCount; i++) {
            IScene *scene = m_scenePanel->GetScene(i);
            if (scene) {
                BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(scene);
                if (btScene) {
                    // Reload preferences in TreeVisualization
                    if (auto *treeVis = btScene->GetTreeVisualization()) {
                        treeVis->LoadPreferences();
                        LOG_INFO("Preferences",
                                 wxString::Format("Reloaded zoom/pan preferences for scene %d", i).ToStdString());
                    }
                }
            }
        }
 
        LOG_INFO("Preferences", "Main Panel settings applied");
    }
 
    // Force layout refresh to account for status bar visibility change
    SendSizeEvent();
 
    LOG_INFO("Preferences", "Preferences refreshed and applied to UI");
}
 
void MainFrame::CreatePanelLayout() {
    // ====== CREATE PANEL INSTANCES ======
 
    // Create left panel container (parent is MainFrame now, not splitter)
    m_leftPanel = new LeftSidePanel(this, this);
 
    // Create main scene panel (center)
    m_scenePanel = new MainPanel(this);
 
    // Set up scene change callback to update hierarchy when switching scene tabs
    m_scenePanel->SetSceneChangedCallback([this](IScene *newScene, int) {
        if (!newScene || newScene->GetSceneType() != "BehaviorTree")
            return;
 
        BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(newScene);
        if (!btScene)
            return;
 
        // Update navigator with the new scene's tree adapter
        if (m_navigatorTab) {
            auto adapter = btScene->GetTreeAdapter();
            if (adapter) {
                m_navigatorTab->SetActiveTree(adapter, m_currentTreeId);
            }
        }
    });
 
    // Create right panel container
    m_rightPanel = new RightSidePanel(this, this);
 
    // Create unified bottom panel
    m_bottomPanel = new BottomPanel(this, this);
 
    // ====== FINISH PANEL SETUP (AFTER CONSTRUCTION) ======
    // Call FinishSetup() after derived classes are fully constructed to ensure
    // proper virtual dispatch for OnPanelSpecificSetup() which creates default tabs
    m_leftPanel->FinishSetup();
    m_rightPanel->FinishSetup();
    m_bottomPanel->FinishSetup();
 
    // ====== GET REFERENCES TO TABS ======
    // Note: Tabs are now created by OnPanelSpecificSetup() and RestoreState()
    // We just need to get references to specific tabs that MainFrame needs
 
    m_propertiesTab = nullptr;
    m_navigatorTab = nullptr;
 
    // ====== SETUP AUI LAYOUT ======
 
    // Get preferences for all panels
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &leftSettings = prefs.GetLeftPanelSettings();
    const auto &rightSettings = prefs.GetRightPanelSettings();
    const auto &bottomSettings = prefs.GetBottomPanelSettings();
 
    // Determine initial visibility for left panel based on startup preference
    bool showLeftPanel = true;
    switch (leftSettings.panelStartupState) {
    case EmberForge::AppPreferences::PanelStartupState::Show:
        showLeftPanel = true;
        break;
    case EmberForge::AppPreferences::PanelStartupState::Hide:
        showLeftPanel = false;
        break;
    case EmberForge::AppPreferences::PanelStartupState::RememberLast:
        showLeftPanel = leftSettings.lastPanelVisible;
        break;
    }
 
    // Get window settings for caption visibility
    const auto &windowSettings = prefs.GetWindowSettings();
 
    // Compute panel pixel sizes from percentages
    wxSize cs = GetClientSize();
    m_lastClientSize = cs;
 
    int leftW = cs.x * leftSettings.defaultPanelWidthPct / 100;
    int leftMinW = cs.x * leftSettings.minimumPanelWidthPct / 100;
 
    // Add all panels to the unified AUI manager
    m_auiManager->AddPane(m_leftPanel, wxAuiPaneInfo()
                                           .Name("left_panel")
                                           .Caption("Left Panel")
                                           .CaptionVisible(windowSettings.showPanelCaptions)
                                           .Left()
                                           .BestSize(wxSize(leftW, -1))
                                           .MinSize(wxSize(leftMinW, -1))
                                           .Dockable(true)
                                           .Floatable(false)
                                           .CloseButton(false)
                                           .Resizable(leftSettings.allowPanelCollapse)
                                           .Show(showLeftPanel));
 
    m_auiManager->AddPane(m_scenePanel, wxAuiPaneInfo()
                                            .Name("scene_panel")
                                            .Caption("Main Panel")
                                            .CenterPane()
                                            .CaptionVisible(windowSettings.showPanelCaptions)
                                            .Dockable(true)
                                            .Floatable(false)
                                            .CloseButton(false)
                                            .Resizable(true));
 
    // Determine initial visibility for right panel based on startup preference
    bool showRightPanel = true;
    switch (rightSettings.panelStartupState) {
    case EmberForge::AppPreferences::PanelStartupState::Show:
        showRightPanel = true;
        break;
    case EmberForge::AppPreferences::PanelStartupState::Hide:
        showRightPanel = false;
        break;
    case EmberForge::AppPreferences::PanelStartupState::RememberLast:
        showRightPanel = rightSettings.lastPanelVisible;
        break;
    }
 
    int rightW = cs.x * rightSettings.defaultPanelWidthPct / 100;
    int rightMinW = cs.x * rightSettings.minimumPanelWidthPct / 100;
 
    m_auiManager->AddPane(m_rightPanel, wxAuiPaneInfo()
                                            .Name("right_panel")
                                            .Caption("Right Panel")
                                            .CaptionVisible(windowSettings.showPanelCaptions)
                                            .Right()
                                            .BestSize(wxSize(rightW, -1))
                                            .MinSize(wxSize(rightMinW, -1))
                                            .Dockable(true)
                                            .Floatable(false)
                                            .CloseButton(false)
                                            .Resizable(rightSettings.allowPanelCollapse)
                                            .Show(showRightPanel));
 
    // Determine initial visibility for bottom panel based on startup preference
    bool showBottomPanel = true;
    switch (bottomSettings.panelStartupState) {
    case EmberForge::AppPreferences::PanelStartupState::Show:
        showBottomPanel = true;
        break;
    case EmberForge::AppPreferences::PanelStartupState::Hide:
        showBottomPanel = false;
        break;
    case EmberForge::AppPreferences::PanelStartupState::RememberLast:
        showBottomPanel = bottomSettings.lastPanelVisible;
        break;
    }
 
    int bottomH = cs.y * bottomSettings.defaultPanelHeightPct / 100;
    int bottomMinH = cs.y * bottomSettings.minimumPanelHeightPct / 100;
 
    m_auiManager->AddPane(m_bottomPanel, wxAuiPaneInfo()
                                             .Name("bottom_panel")
                                             .Caption("Bottom Panel")
                                             .CaptionVisible(windowSettings.showPanelCaptions)
                                             .Bottom()
                                             .BestSize(wxSize(-1, bottomH))
                                             .MinSize(wxSize(-1, bottomMinH))
                                             .Dockable(true)
                                             .Floatable(false)
                                             .CloseButton(false)
                                             .Resizable(bottomSettings.allowPanelCollapse)
                                             .Show(showBottomPanel));
 
    // Track proportional panes for dynamic resizing
    double leftProp = leftSettings.defaultPanelWidthPct / 100.0;
    double leftMinProp = leftSettings.minimumPanelWidthPct / 100.0;
    double rightProp = rightSettings.defaultPanelWidthPct / 100.0;
    double rightMinProp = rightSettings.minimumPanelWidthPct / 100.0;
    double bottomProp = bottomSettings.defaultPanelHeightPct / 100.0;
    double bottomMinProp = bottomSettings.minimumPanelHeightPct / 100.0;
 
    m_layout.Track("left_panel", leftProp, leftMinProp, true);
    m_layout.Track("right_panel", rightProp, rightMinProp, true);
    m_layout.Track("bottom_panel", bottomProp, bottomMinProp, false);
 
    // Update the AUI layout
    m_auiManager->Update();
 
    // Apply panel preferences after AUI setup
    m_leftPanel->ApplyPreferences();
    m_leftPanel->RestoreState();
 
    // Get reference to hierarchy/navigator tabs after they're created by RestoreState
    auto *notebook = m_leftPanel->GetNotebook();
    if (notebook) {
        for (size_t i = 0; i < notebook->GetPageCount(); ++i) {
            auto *page = notebook->GetPage(i);
            auto *tab = dynamic_cast<ITab *>(page);
            if (tab && tab->GetTabType() == "Navigator") {
                auto *navTab = dynamic_cast<ForgeNavigatorTab *>(page);
                if (navTab) {
                    UpdateNavigatorTabReference(navTab);
                    LOG_INFO("MainFrame", "Found navigator tab reference");
                }
            }
        }
    }
    // Also check right panel for navigator tab
    if (auto *rightNb = m_rightPanel ? m_rightPanel->GetNotebook() : nullptr) {
        for (size_t i = 0; i < rightNb->GetPageCount(); ++i) {
            auto *page = rightNb->GetPage(i);
            auto *tab = dynamic_cast<ITab *>(page);
            if (tab && tab->GetTabType() == "Navigator") {
                auto *navTab = dynamic_cast<ForgeNavigatorTab *>(page);
                if (navTab) {
                    UpdateNavigatorTabReference(navTab);
                    LOG_INFO("MainFrame", "Found navigator tab reference in right panel");
                }
            }
        }
    }
 
    m_rightPanel->ApplyPreferences();
    m_rightPanel->RestoreState();
 
    // Get reference to properties tab after it's created by RestoreState
    auto *rightNotebook = m_rightPanel->GetNotebook();
    if (rightNotebook) {
        for (size_t i = 0; i < rightNotebook->GetPageCount(); ++i) {
            auto *page = rightNotebook->GetPage(i);
            auto *tab = dynamic_cast<ITab *>(page);
            if (tab && tab->GetTabType() == "Properties") {
                m_propertiesTab = dynamic_cast<PropertiesTab *>(page);
                LOG_INFO("MainFrame", "Found properties tab reference");
                break;
            }
        }
    }
 
    m_bottomPanel->ApplyPreferences();
    m_bottomPanel->RestoreState();
 
    // Update button bitmaps to match initial panel visibility
    if (m_panelToggleToolbar) {
        wxString resourcePath = EmberForge::ResourcePath::GetDir("buttons");
 
        // Update left panel button
        wxWindow *leftWin = m_panelToggleToolbar->FindWindow(ID_ToggleLeftPanel);
        if (leftWin) {
            wxBitmapButton *leftBtn = dynamic_cast<wxBitmapButton *>(leftWin);
            if (leftBtn) {
                if (showLeftPanel) {
                    leftBtn->SetBitmap(
                        wxBitmap(resourcePath + "left_panel/Left_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
                } else {
                    leftBtn->SetBitmap(
                        wxBitmap(resourcePath + "left_panel/Left_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
                }
            }
        }
 
        // Update bottom panel button
        wxWindow *bottomWin = m_panelToggleToolbar->FindWindow(ID_ToggleBottomPanel);
        if (bottomWin) {
            wxBitmapButton *bottomBtn = dynamic_cast<wxBitmapButton *>(bottomWin);
            if (bottomBtn) {
                if (showBottomPanel) {
                    bottomBtn->SetBitmap(
                        wxBitmap(resourcePath + "bottom_panel/Bottom_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
                } else {
                    bottomBtn->SetBitmap(
                        wxBitmap(resourcePath + "bottom_panel/Bottom_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
                }
            }
        }
 
        // Update right panel button
        wxWindow *rightWin = m_panelToggleToolbar->FindWindow(ID_ToggleRightPanel);
        if (rightWin) {
            wxBitmapButton *rightBtn = dynamic_cast<wxBitmapButton *>(rightWin);
            if (rightBtn) {
                if (showRightPanel) {
                    rightBtn->SetBitmap(
                        wxBitmap(resourcePath + "right_panel/Right_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
                } else {
                    rightBtn->SetBitmap(
                        wxBitmap(resourcePath + "right_panel/Right_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
                }
            }
        }
    }
 
    LOG_INFO("AUI", wxString::Format(
                        "Created unified AUI layout - left panel: %d%% (min %d%%), visible=%d; right panel: "
                        "%d%% (min %d%%), visible=%d; bottom panel: %d%% (min %d%%), visible=%d",
                        leftSettings.defaultPanelWidthPct, leftSettings.minimumPanelWidthPct, showLeftPanel,
                        rightSettings.defaultPanelWidthPct, rightSettings.minimumPanelWidthPct, showRightPanel,
                        bottomSettings.defaultPanelHeightPct, bottomSettings.minimumPanelHeightPct, showBottomPanel)
                        .ToStdString());
}
 
// ====== PERFORMANCE MONITORING EVENT HANDLERS ======
 
void MainFrame::OnPaint(wxPaintEvent &event) {
    // Standard paint handling
    event.Skip();
}
 
void MainFrame::OnIdle(wxIdleEvent &event) {
    // Update system metrics periodically during idle time
    static int idleCount = 0;
    if (++idleCount % 100 == 0) { // Every 100 idle events
        EmberForge::PerformanceMonitor &monitor = EmberForge::PerformanceMonitor::GetInstance();
        if (monitor.IsEnabled()) {
            monitor.UpdateSystemMetrics();
        }
    }
    event.Skip();
}
 
void MainFrame::OnFrameResize(wxSizeEvent &event) {
    wxSize newSize = GetClientSize();
    if (m_auiManager && m_lastClientSize.x > 0 && m_lastClientSize.y > 0) {
        m_layout.HandleResize(m_auiManager, m_lastClientSize, newSize);
        m_auiManager->Update();
    }
    m_lastClientSize = newSize;
    event.Skip();
}
 
// ====== EVENT HANDLERS (SIMPLIFIED) ======
 
void MainFrame::OnExit(wxCommandEvent &event) { Close(true); }
 
void MainFrame::OnAbout(wxCommandEvent &event) {
    wxMessageBox("This is a refactored wxWidgets application for EmberForge\n\n"
                 "Now with better code organization using separate panel classes!",
                 "About EmberForge", wxOK | wxICON_INFORMATION);
}
 
void MainFrame::OnLoadXML(wxCommandEvent &event) {
    wxFileDialog openFileDialog(this, "Open Behavior Tree", "", "", "XML files (*.xml)|*.xml|All files (*.*)|*.*",
                                wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 
    if (openFileDialog.ShowModal() == wxID_CANCEL)
        return; // the user changed their mind
 
    wxString filePath = openFileDialog.GetPath();
    wxString ext = wxFileName(filePath).GetExt().Lower();
 
    // Check if file is XML
    if (ext != "xml") {
        wxString message = wxString::Format("Unsupported File Format\n\n"
                                            "File: %s\n"
                                            "Extension: .%s\n\n"
                                            "EmberForge currently only supports opening XML behavior tree files.\n"
                                            "Please select an XML file (.xml) to open.",
                                            wxFileName(filePath).GetFullName(), ext.IsEmpty() ? "none" : ext);
 
        wxMessageBox(message, "Unsupported File Format", wxOK | wxICON_WARNING, this);
        LOG_WARNING("FileOpen", std::string("Attempted to open unsupported file type: .") + ext.ToStdString());
        return;
    }
 
    LoadXMLFile(filePath);
}
 
void MainFrame::LoadXMLFile(const wxString &filePath, bool confirmOverride) {
    LOG_INFO("Parser", std::string("Loading XML file: ") + filePath.ToStdString());
 
    // Variables to track user preferences for renaming
    bool shouldRename = false;
    wxString newSceneName;
 
    // NOTE: OverrideSceneDialog is temporarily disabled
    // If confirmation is requested, show custom dialog with rename options
    // if (confirmOverride) {
    //     wxFileName fileName(filePath);
    //     EmberForge::OverrideSceneDialog confirmDialog(this, fileName.GetFullName());
    //
    //     if (confirmDialog.ShowModal() != wxID_OK) {
    //         LOG_INFO("Parser", "User cancelled XML loading");
    //         return;
    //     }
    //
    //     // Get user preferences from dialog
    //     shouldRename = confirmDialog.ShouldRename();
    //     newSceneName = confirmDialog.GetSceneName();
    // }
    (void)confirmOverride; // Suppress unused parameter warning
 
    // Create detailed loading dialog with scrollable log
    LoadingDialog loadingDialog(this, "Loading Behavior Tree (libxml2)");
    loadingDialog.SetMaxProgress(5);
    loadingDialog.Show(true);
    loadingDialog.AppendLog("Selected file: " + filePath, "[FILE]");
    wxYield(); // Force UI update
 
    // Create a progress callback adapter
    class ProgressCallback : public EmberCore::IParseProgressCallback {
      private:
        LoadingDialog *dialog_;
 
      public:
        explicit ProgressCallback(LoadingDialog *dialog) : dialog_(dialog) {}
 
        bool OnProgress(const EmberCore::String &message, int current, int total) override {
            if (dialog_) {
                // Update progress with detailed message
                bool shouldContinue = dialog_->UpdateProgress(current, total, message);
 
                // Add a small delay to make progress visible (especially for small files)
                wxMilliSleep(50);
 
                return shouldContinue;
            }
            return true;
        }
 
        // Additional method to append detailed log messages
        void AppendLog(const wxString &message, const wxString &prefix = "") {
            if (dialog_) {
                dialog_->AppendLog(message, prefix);
            }
        }
    };
 
    ProgressCallback progressCallback(&loadingDialog);
 
    // Get parser config from ConfigManager
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    auto activeProfile = configMgr.GetActiveProfile();
    auto parserConfig = activeProfile ? activeProfile->GetConfig() : EmberCore::ParserConfig::CreateDefault();
 
    // Create libxml2 parser with active config and set progress callback
    EmberCore::LibXMLBehaviorTreeParser parser(parserConfig);
    parser.SetProgressCallback(&progressCallback);
 
    // Add initial parsing logs
    progressCallback.AppendLog("libxml2 parser initialized", "[INIT]");
    progressCallback.AppendLog("Starting file parsing with libxml2...", "[INFO]");
 
    // Load the XML with progress reporting
    auto behaviorTree = parser.ParseFromFile(filePath.ToStdString());
 
    // Show completion
    if (!loadingDialog.WasCancelled()) {
        loadingDialog.UpdateProgress(5, 5, "Complete!");
        loadingDialog.AppendLog("libxml2 parsing completed successfully", "[COMPLETE]");
        wxMilliSleep(800); // Show completion message briefly
    }
 
    // Mark as complete and keep dialog open for review
    loadingDialog.MarkComplete();
 
    if (!behaviorTree) {
        // Show parsing errors in the dialog
        const auto &errors = parser.GetErrors();
        for (const auto &error : errors) {
            loadingDialog.AppendLog(wxString::FromUTF8(error.message), "[ERROR]");
        }
 
        // Keep dialog open for user to review
        loadingDialog.ShowModal();
 
        wxString errorMessage = "Failed to parse XML file with libxml2:\n\n";
        for (const auto &error : errors) {
            errorMessage += "• " + error.message + "\n";
        }
 
        wxMessageBox(errorMessage, "libxml2 XML Parsing Error", wxOK | wxICON_ERROR);
        LOG_ERROR("Parser", "libxml2 XML parsing failed");
        return;
    }
 
    // Keep dialog open for user to review logs before continuing
    loadingDialog.ShowModal();
 
    LOG_INFO("Parser", "libxml2 XML parsed successfully, loading into scene view");
 
    // Validate that the main tree has actual content (not just empty nodes)
    if (behaviorTree->HasRootNode()) {
        EmberCore::Node *rootNode = behaviorTree->GetRootNode();
        if (rootNode) {
            // Check if the root node has no children (likely due to skipped SubTree nodes)
            if (rootNode->GetChildCount() == 0) {
                wxMessageBox("Cannot load behavior tree: The main tree appears to be empty.\n\n"
                             "This usually happens when the tree contains only SubTree nodes,\n"
                             "which are not yet implemented in the parser.",
                             "Empty Behavior Tree", wxOK | wxICON_WARNING);
                LOG_WARNING("Parser", "Refusing to load empty behavior tree - root node '" + rootNode->GetName() +
                                          "' has no children");
                return;
            }
        }
    }
 
    // Get the scene panel and load the parsed tree
    if (m_scenePanel) {
        auto activeScene = m_scenePanel->GetActiveScene();
        if (activeScene) {
            auto treeVis = dynamic_cast<BehaviorTreeScene *>(activeScene);
            if (treeVis) {
                // Load the parsed tree into the scene
                // Create DirectTreeAdapter from the parsed BehaviorTree (same as old parser)
                auto directAdapter = std::make_shared<EmberCore::DirectTreeAdapter>(behaviorTree);
                treeVis->SetBehaviorTree(directAdapter);
 
                // Update navigator with the new tree
                if (m_navigatorTab && directAdapter && directAdapter->HasRootNode()) {
                    wxFileName fn(filePath);
                    m_navigatorTab->SetActiveTree(directAdapter, fn.GetName().ToStdString());
                }
 
                if (auto *visualization = treeVis->GetTreeVisualization()) {
                    visualization->RefreshCanvas();
                    visualization->Refresh();
                    visualization->Update();
 
                    if (directAdapter && directAdapter->HasRootNode()) {
                        CallAfter([visualization, directAdapter]() {
                            visualization->CenterOnNode(directAdapter->GetRootNode());
                            LOG_INFO("Parser", "Centered view on root node after loading XML (UniParser)");
                        });
                    }
                }
                treeVis->Refresh();
                m_scenePanel->Refresh();
                m_scenePanel->Update();
 
                // Track the current file path for save operations
                m_currentFilePath = filePath;
                m_treeModified = false;
 
                // Save the last opened file path to preferences
                auto &parserPrefs =
                    EmberForge::AppPreferencesManager::GetInstance().GetPreferences().GetParserSettings();
                parserPrefs.lastOpenedFilePath = filePath.ToStdString();
                EmberForge::AppPreferencesManager::GetInstance().GetPreferences().SaveToFile(
                    EmberForge::AppPreferences::GetDefaultConfigPath());
                LOG_INFO("Preferences", "Saved last opened file path: " + filePath.ToStdString());
 
                // Update the scene title with the filename
                // NOTE: Custom rename via OverrideSceneDialog is temporarily disabled
                {
                    wxFileName fileName(filePath);
                    wxString sceneName = fileName.GetName();
                    m_scenePanel->UpdateActiveSceneTitle(sceneName);
                }
                (void)shouldRename; // Suppress unused variable warning
                (void)newSceneName; // Suppress unused variable warning
 
                m_scenePanel->ShowScenes();
 
                LOG_INFO("Parser", "Behavior tree loaded into scene view");
                SetStatusText("Loaded with libxml2: " + wxFileName(filePath).GetName());
            } else {
                LOG_ERROR("Parser", "Active scene is not a behavior tree scene");
                wxMessageBox("Active scene is not a behavior tree scene", "Error", wxOK | wxICON_ERROR);
            }
        } else {
            LOG_ERROR("Parser", "No active scene available");
            wxMessageBox("No active scene available", "Error", wxOK | wxICON_ERROR);
        }
    } else {
        LOG_ERROR("Parser", "Scene panel not available");
        wxMessageBox("Scene panel not available", "Error", wxOK | wxICON_ERROR);
    }
}
 
void MainFrame::LoadXMLFileInNewScene(const wxString &filePath) {
    if (!m_scenePanel) {
        LOG_ERROR("Parser", "Scene panel not available");
        wxMessageBox("Scene panel not available", "Error", wxOK | wxICON_ERROR);
        return;
    }
 
    // Extract filename without extension to use as scene name
    wxFileName fileName(filePath);
    wxString sceneName = fileName.GetName();
 
    // Create a new scene with the XML filename
    LOG_INFO("Parser", std::string("Creating new scene: ") + sceneName.ToStdString());
    int sceneIndex = m_scenePanel->CreateNewScene(sceneName);
 
    if (sceneIndex < 0) {
        LOG_ERROR("Parser", "Failed to create new scene (limit may have been reached)");
        return;
    }
 
    m_scenePanel->ShowScenes();
 
    // The new scene is now active, so load the XML into it
    LoadXMLFile(filePath);
}
 
void MainFrame::OnSaveXML(wxCommandEvent &event) {
    // If no current file path, redirect to Save As
    if (m_currentFilePath.IsEmpty()) {
        OnSaveAsXML(event);
        return;
    }
 
    // Save to existing path
    DoSaveXML(m_currentFilePath);
}
 
void MainFrame::OnSaveAsXML(wxCommandEvent &event) {
    wxFileDialog saveFileDialog(this, "Save Behavior Tree XML", "", "", "XML files (*.xml)|*.xml",
                                wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 
    if (saveFileDialog.ShowModal() == wxID_CANCEL)
        return;
 
    wxString filePath = saveFileDialog.GetPath();
    DoSaveXML(filePath);
}
 
void MainFrame::DoSaveXML(const wxString &filePath) {
    LOG_INFO("Serializer", "Saving behavior tree to: " + filePath.ToStdString());
 
    // 1. Get current behavior tree from scene
    auto behaviorTreeScene = dynamic_cast<BehaviorTreeScene *>(m_scenePanel->GetActiveScene());
    if (!behaviorTreeScene) {
        wxMessageBox("No behavior tree scene is currently active", "Save Error", wxOK | wxICON_ERROR);
        LOG_ERROR("Serializer", "No behavior tree scene is active");
        return;
    }
 
    // Get the abstracted tree (ITreeStructure)
    auto treeStructure = behaviorTreeScene->GetAbstractedTree();
    if (!treeStructure) {
        wxMessageBox("No behavior tree is currently loaded", "Save Error", wxOK | wxICON_ERROR);
        LOG_ERROR("Serializer", "No behavior tree is loaded");
        return;
    }
 
    // Cast to DirectTreeAdapter to access GetTree()
    auto adapter = dynamic_cast<EmberCore::DirectTreeAdapter *>(treeStructure);
    if (!adapter) {
        wxMessageBox("Unexpected tree adapter type", "Save Error", wxOK | wxICON_ERROR);
        LOG_ERROR("Serializer", "Tree adapter is not a DirectTreeAdapter");
        return;
    }
 
    // 2. Get BehaviorTree from adapter
    std::shared_ptr<EmberCore::BehaviorTree> tree = adapter->GetTree();
    if (!tree) {
        wxMessageBox("Failed to access behavior tree data", "Save Error", wxOK | wxICON_ERROR);
        LOG_ERROR("Serializer", "Failed to get tree from adapter");
        return;
    }
 
    // 3. Get parser config for validation
    auto &configMgr = EmberCore::ConfigManager::GetInstance();
    auto activeProfile = configMgr.GetActiveProfile();
    auto parserConfig = activeProfile ? activeProfile->GetConfig() : EmberCore::ParserConfig::CreateDefault();
 
    // 4. Validate tree using unified validator
    EmberCore::BehaviorTreeValidator validator(parserConfig);
    auto validation = validator.Validate(tree.get());
 
    // Build validation message with clear separation of errors and warnings
    bool hasIssues = validation.HasErrors() || validation.HasWarnings();
    if (hasIssues) {
        wxString msg;
 
        // Show errors (during development, these are warnings that can be overridden)
        if (validation.HasErrors()) {
            msg += "⚠️ VALIDATION ERRORS (development mode allows saving):\n\n";
            for (const auto &issue : validation.issues) {
                if (issue.severity == EmberCore::BehaviorTreeValidator::Severity::ERROR) {
                    wxString path = wxString::FromUTF8(issue.node_path.c_str());
                    wxString message = wxString::FromUTF8(issue.message.c_str());
                    if (!path.empty()) {
                        msg += "• [" + path + "] " + message + "\n";
                    } else {
                        msg += "• " + message + "\n";
                    }
                    LOG_WARNING("Serializer", "Validation error: " + issue.message);
                }
            }
            msg += "\n";
        }
 
        // Show warnings
        if (validation.HasWarnings()) {
            msg += "ℹ️ VALIDATION WARNINGS:\n\n";
            for (const auto &issue : validation.issues) {
                if (issue.severity == EmberCore::BehaviorTreeValidator::Severity::WARNING) {
                    wxString path = wxString::FromUTF8(issue.node_path.c_str());
                    wxString message = wxString::FromUTF8(issue.message.c_str());
                    if (!path.empty()) {
                        msg += "• [" + path + "] " + message + "\n";
                    } else {
                        msg += "• " + message + "\n";
                    }
                    LOG_INFO("Serializer", "Validation warning: " + issue.message);
                }
            }
            msg += "\n";
        }
 
        msg += "These issues may cause problems when loading the file.\n";
        msg += "Save anyway? (Development workflow)";
 
        wxString title = validation.HasErrors() ? "Validation Issues" : "Validation Warnings";
        int result = wxMessageBox(msg, title, wxYES_NO | wxICON_WARNING);
        if (result != wxYES) {
            LOG_INFO("Serializer", "Save cancelled by user due to validation issues");
            return;
        }
    }
 
    // 5. Serialize using LibXMLBehaviorTreeSerializer
    EmberCore::LibXMLBehaviorTreeSerializer serializer(parserConfig);
    if (serializer.SerializeToFile(tree, filePath.ToStdString())) {
        m_currentFilePath = filePath;
        m_treeModified = false;
        SetStatusText("Saved: " + wxFileName(filePath).GetName());
        LOG_INFO("Serializer", "Tree saved successfully to: " + filePath.ToStdString());
 
        wxMessageBox("Behavior tree saved successfully!", "Save Complete", wxOK | wxICON_INFORMATION);
    } else {
        // Show serialization errors
        wxString errorMessage = "Failed to save XML file:\n\n";
        const auto &errors = serializer.GetErrors();
        for (const auto &error : errors) {
            errorMessage += "• " + wxString::FromUTF8(error.message.c_str()) + "\n";
        }
 
        wxMessageBox(errorMessage, "Save Error", wxOK | wxICON_ERROR);
        LOG_ERROR("Serializer", "Failed to save tree to: " + filePath.ToStdString());
    }
}
 
// Settings menu event handlers
void MainFrame::OnPreferences(wxCommandEvent &event) {
    PreferencesDialog dialog(this);
    int result = dialog.ShowModal();
 
    if (result == wxID_OK) {
        LOG_INFO("Config", "Preferences dialog closed with OK - settings applied");
        SetStatusText("Preferences updated");
 
        // Apply preferences immediately
        RefreshPreferences();
    } else {
        LOG_INFO("Config", "Preferences dialog cancelled");
        SetStatusText("Preferences cancelled");
    }
}
 
void MainFrame::OnToggleLeftPanel(wxCommandEvent &event) {
    if (!m_auiManager)
        return;
 
    wxAuiPaneInfo &pane = m_auiManager->GetPane("left_panel");
    if (pane.IsOk()) {
        pane.Show(!pane.IsShown());
        m_auiManager->Update();
 
        // Update button bitmap to reflect toggle state
        wxBitmapButton *btn = dynamic_cast<wxBitmapButton *>(event.GetEventObject());
        if (btn) {
            wxString resourcePath = EmberForge::ResourcePath::GetDir("buttons/left_panel");
            if (pane.IsShown()) {
                btn->SetBitmap(wxBitmap(resourcePath + "Left_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
            } else {
                btn->SetBitmap(wxBitmap(resourcePath + "Left_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
            }
        }
 
        LOG_INFO("UI", std::string("Left panel ") + (pane.IsShown() ? "shown" : "hidden"));
        SetStatusText(pane.IsShown() ? "Left panel shown" : "Left panel hidden");
    }
}
 
void MainFrame::OnToggleBottomPanel(wxCommandEvent &event) {
    if (!m_auiManager)
        return;
 
    wxAuiPaneInfo &pane = m_auiManager->GetPane("bottom_panel");
    if (pane.IsOk()) {
        pane.Show(!pane.IsShown());
        m_auiManager->Update();
 
        // Update button bitmap to reflect toggle state
        wxBitmapButton *btn = dynamic_cast<wxBitmapButton *>(event.GetEventObject());
        if (btn) {
            wxString resourcePath = EmberForge::ResourcePath::GetDir("buttons/bottom_panel");
            if (pane.IsShown()) {
                btn->SetBitmap(wxBitmap(resourcePath + "Bottom_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
            } else {
                btn->SetBitmap(wxBitmap(resourcePath + "Bottom_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
            }
        }
 
        LOG_INFO("UI", std::string("Bottom panel ") + (pane.IsShown() ? "shown" : "hidden"));
        SetStatusText(pane.IsShown() ? "Bottom panel shown" : "Bottom panel hidden");
    }
}
 
void MainFrame::OnToggleRightPanel(wxCommandEvent &event) {
    if (!m_auiManager)
        return;
 
    wxAuiPaneInfo &pane = m_auiManager->GetPane("right_panel");
    if (pane.IsOk()) {
        pane.Show(!pane.IsShown());
        m_auiManager->Update();
 
        // Update button bitmap to reflect toggle state
        wxBitmapButton *btn = dynamic_cast<wxBitmapButton *>(event.GetEventObject());
        if (btn) {
            wxString resourcePath = EmberForge::ResourcePath::GetDir("buttons/right_panel");
            if (pane.IsShown()) {
                btn->SetBitmap(wxBitmap(resourcePath + "Right_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
            } else {
                btn->SetBitmap(wxBitmap(resourcePath + "Right_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
            }
        }
 
        LOG_INFO("UI", std::string("Right panel ") + (pane.IsShown() ? "shown" : "hidden"));
        SetStatusText(pane.IsShown() ? "Right panel shown" : "Right panel hidden");
    }
}
 
void MainFrame::UpdatePanelToggleButtons() {
    if (!m_panelToggleToolbar || !m_auiManager)
        return;
 
    wxString resourcePath = EmberForge::ResourcePath::GetDir("buttons");
 
    // Update left panel button
    wxAuiPaneInfo &leftPane = m_auiManager->GetPane("left_panel");
    wxWindow *leftWin = m_panelToggleToolbar->FindWindow(ID_ToggleLeftPanel);
    if (leftWin && leftPane.IsOk()) {
        wxBitmapButton *leftBtn = dynamic_cast<wxBitmapButton *>(leftWin);
        if (leftBtn) {
            if (leftPane.IsShown()) {
                leftBtn->SetBitmap(wxBitmap(resourcePath + "left_panel/Left_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
            } else {
                leftBtn->SetBitmap(wxBitmap(resourcePath + "left_panel/Left_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
            }
        }
    }
 
    // Update bottom panel button
    wxAuiPaneInfo &bottomPane = m_auiManager->GetPane("bottom_panel");
    wxWindow *bottomWin = m_panelToggleToolbar->FindWindow(ID_ToggleBottomPanel);
    if (bottomWin && bottomPane.IsOk()) {
        wxBitmapButton *bottomBtn = dynamic_cast<wxBitmapButton *>(bottomWin);
        if (bottomBtn) {
            if (bottomPane.IsShown()) {
                bottomBtn->SetBitmap(
                    wxBitmap(resourcePath + "bottom_panel/Bottom_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
            } else {
                bottomBtn->SetBitmap(
                    wxBitmap(resourcePath + "bottom_panel/Bottom_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
            }
        }
    }
 
    // Update right panel button
    wxAuiPaneInfo &rightPane = m_auiManager->GetPane("right_panel");
    wxWindow *rightWin = m_panelToggleToolbar->FindWindow(ID_ToggleRightPanel);
    if (rightWin && rightPane.IsOk()) {
        wxBitmapButton *rightBtn = dynamic_cast<wxBitmapButton *>(rightWin);
        if (rightBtn) {
            if (rightPane.IsShown()) {
                rightBtn->SetBitmap(
                    wxBitmap(resourcePath + "right_panel/Right_Panel_Pressed_22.png", wxBITMAP_TYPE_PNG));
            } else {
                rightBtn->SetBitmap(
                    wxBitmap(resourcePath + "right_panel/Right_Panel_Normal_22.png", wxBITMAP_TYPE_PNG));
            }
        }
    }
}
 
int MainFrame::CountTabGlobally(const wxString &tabName) const {
    int count = 0;
    if (m_leftPanel && m_leftPanel->HasTabWithName(tabName)) {
        count++;
    }
    if (m_rightPanel && m_rightPanel->HasTabWithName(tabName)) {
        count++;
    }
    if (m_bottomPanel && m_bottomPanel->HasTabWithName(tabName)) {
        count++;
    }
    return count;
}
 
void MainFrame::OnParserConfig(wxCommandEvent &event) {
    ParserConfigDialog dialog(this);
    int result = dialog.ShowModal();
 
    if (result == wxID_OK) {
        LOG_INFO("Config", "Parser configuration updated");
        SetStatusText("Parser configuration saved");
    } else {
        LOG_INFO("Config", "Parser configuration cancelled");
        SetStatusText("Parser configuration cancelled");
    }
}
 
// Tool button event handlers (delegated to panels)
void MainFrame::OnEditorTool(wxCommandEvent &event) {
    PERF_TIME_BEGIN(editor_tool_operation);
    LOG_INFO("Tool", "Editor Tool activated - Opening editor for BT configuration");
    PERF_TIME_END(editor_tool_operation);
}
 
void MainFrame::OnMonitorTool(wxCommandEvent &event) {
    PERF_TIME_BEGIN(monitor_tool_operation);
    LOG_INFO("Tool", "Monitor Tool activated - Opening performance monitor");
    PERF_TIME_END(monitor_tool_operation);
}
 
void MainFrame::OnLogReplayTool(wxCommandEvent &event) {
    PERF_TIME_BEGIN(log_replay_tool_operation);
    LOG_INFO("Tool", "Log Replay Tool activated - Replaying performance logs");
    PERF_TIME_END(log_replay_tool_operation);
}
 
// View menu event handlers
void MainFrame::OnToggleMaximize(wxCommandEvent &event) {
    PERF_TIME_BEGIN(maximize_toggle);
    bool isMaximized = IsMaximized();
    if (!isMaximized) {
        Maximize(true);
        LOG_INFO("View", "Maximized window");
    } else {
        Maximize(false);
        LOG_INFO("View", "Restored window to normal size");
    }
    PERF_TIME_END(maximize_toggle);
}
 
void MainFrame::OnNextScene(wxCommandEvent &event) {
    if (m_scenePanel) {
        m_scenePanel->SwitchToNextScene();
    }
}
 
void MainFrame::OnPreviousScene(wxCommandEvent &event) {
    if (m_scenePanel) {
        m_scenePanel->SwitchToPreviousScene();
    }
}
 
void MainFrame::OnResetZoom(wxCommandEvent &event) {
    if (m_scenePanel) {
        IScene *activeScene = m_scenePanel->GetActiveScene();
        if (activeScene) {
            // Try to cast to BehaviorTreeScene to access view reset functionality
            BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
            if (btScene && btScene->GetTreeVisualization()) {
                // Reset view (zoom + pan to default)
                btScene->GetTreeVisualization()->ResetView();
 
                auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
                float defaultZoom = prefs.GetMainPanelSettings().defaultZoomLevel;
                int zoomPercent = static_cast<int>(defaultZoom * 100);
 
                SetStatusText(wxString::Format("View reset (zoom: %d%%)", zoomPercent));
                LOG_INFO("View", "View reset to default (zoom + pan)");
            }
        }
    }
}
 
void MainFrame::OnResetUI(wxCommandEvent &event) {
    // Confirm with user
    int result = wxMessageBox("This will:\n"
                              "- Close the current project (if open)\n"
                              "- Reset all preferences to defaults\n"
                              "- Reset all panels to their default tabs\n\n"
                              "Are you sure you want to reset the UI?",
                              "Reset UI", wxYES_NO | wxICON_WARNING, this);
 
    if (result != wxYES) {
        return;
    }
 
    LOG_INFO("UI", "Resetting UI to defaults");
 
    // 1. Close the project if one is open
    if (m_activeProject) {
        CloseProject();
        LOG_INFO("UI", "Closed active project");
    }
 
    // 2. Reset preferences to defaults
    auto &prefsMgr = EmberForge::AppPreferencesManager::GetInstance();
    EmberForge::AppPreferences defaultPrefs;
    prefsMgr.GetPreferences() = defaultPrefs;
 
    std::string configPath = EmberForge::AppPreferences::GetDefaultConfigPath();
    prefsMgr.GetPreferences().SaveToFile(configPath);
    LOG_INFO("Preferences", "Reset preferences to defaults and saved to: " + configPath);
 
    // 3. Reset panels - show them if hidden and set to default tabs only
    // Show all panels first
    if (m_auiManager) {
        wxAuiPaneInfo &leftPane = m_auiManager->GetPane("left_panel");
        if (leftPane.IsOk() && !leftPane.IsShown()) {
            leftPane.Show();
        }
 
        wxAuiPaneInfo &rightPane = m_auiManager->GetPane("right_panel");
        if (rightPane.IsOk() && !rightPane.IsShown()) {
            rightPane.Show();
        }
 
        wxAuiPaneInfo &bottomPane = m_auiManager->GetPane("bottom_panel");
        if (bottomPane.IsOk() && !bottomPane.IsShown()) {
            bottomPane.Show();
        }
 
        m_auiManager->Update();
    }
 
    // Reset each panel to its default tab
    // Phase 1: Clear all panels first to avoid global instance limit conflicts
    if (m_leftPanel) {
        m_leftPanel->ClearAllTabs();
    }
    if (m_rightPanel) {
        m_rightPanel->ClearAllTabs();
    }
    if (m_bottomPanel) {
        m_bottomPanel->ClearAllTabs();
    }
 
    // Phase 2: Now create default tabs (global instance checks will pass)
    if (m_leftPanel) {
        m_leftPanel->ResetToDefaultTab(EmberForge::TabType::Navigator);
    }
    if (m_rightPanel) {
        m_rightPanel->ResetToDefaultTab(EmberForge::TabType::Properties);
    }
    if (m_bottomPanel) {
        m_bottomPanel->ResetToDefaultTab(EmberForge::TabType::FileExplorer);
    }
 
    // 4. Update the visuals
    UpdatePanelToggleButtons();
    RefreshPreferences();
    RefreshMenuHotkeys();
 
    // Force a full layout update
    if (m_auiManager) {
        m_auiManager->Update();
    }
    Layout();
    Refresh();
 
    SetStatusText("UI reset to defaults");
    LOG_INFO("UI", "UI reset complete");
}
 
void MainFrame::LogMessage(const wxString &message) {
    if (m_bottomPanel && m_bottomPanel->GetLogOutput()) {
        wxDateTime now = wxDateTime::Now();
        wxString timestamp = now.Format("%Y-%m-%d %H:%M:%S");
        wxString logEntry = wxString::Format("%s %s\n", timestamp, message);
 
        m_bottomPanel->GetLogOutput()->AppendText(logEntry);
        m_bottomPanel->GetLogOutput()->SetInsertionPointEnd();
    }
}
 
void MainFrame::OnHierarchySelectionChanged(EmberCore::ITreeNode *selectedNode) {
    // Called when user selects a node in Navigator's hierarchy view
    // Check if hierarchy → scene sync is enabled
    auto &config = EmberCore::BehaviorTreeConfigManager::GetInstance().GetConfig();
    if (!config.GetSyncSettings().enableHierarchyToScene) {
        if (config.GetDebugSettings().enableSyncLogging) {
            LOG_INFO("Sync", "Hierarchy → Scene: Disabled by configuration");
        }
        return;
    }
 
    // Prevent infinite loops
    if (m_isUpdatingFromScene) {
        if (config.GetDebugSettings().enableSyncLogging) {
            LOG_INFO("Sync", "Hierarchy → Scene: Skipped (already updating from scene)");
        }
        return;
    }
 
    // Debug logging
    if (config.GetDebugSettings().enableSyncLogging) {
        LOG_INFO("Sync", "Hierarchy → Scene: Node selected in hierarchy tab");
    }
 
    // Set flag to prevent loops
    m_isUpdatingFromHierarchy = true;
 
    // Safety check: Ensure scene panel exists and is valid
    if (!m_scenePanel) {
        LOG_ERROR("Sync", "Scene panel is null");
        m_isUpdatingFromHierarchy = false;
        return;
    }
 
    // Get the active scene and check if it's a behavior tree scene
    IScene *activeScene = m_scenePanel->GetActiveScene();
    if (!activeScene || activeScene->GetSceneType() != "BehaviorTree") {
        LOG_ERROR("Sync", "No active behavior tree scene");
        m_isUpdatingFromHierarchy = false;
        return;
    }
 
    // Cast to BehaviorTreeScene to access tree visualization
    BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
    if (!btScene) {
        LOG_ERROR("Sync", "Failed to cast to BehaviorTreeScene");
        m_isUpdatingFromHierarchy = false;
        return;
    }
 
    auto *treeVis = btScene->GetTreeVisualization();
    if (!treeVis) {
        LOG_ERROR("Sync", "Tree visualization is null");
        m_isUpdatingFromHierarchy = false;
        return;
    }
 
    // Additional safety: Check if the scene's panel is still valid
    wxPanel *scenePanel = btScene->GetPanel();
    if (!scenePanel || !scenePanel->IsShown()) {
        LOG_ERROR("Sync", "Scene panel is not shown");
        m_isUpdatingFromHierarchy = false;
        return;
    }
 
    // Set the selected node in the scene view if highlighting is enabled
    // Note: Centering on node is NOT done here - it's only done on double-click
    // when the doubleClickAction preference is set to CenterInCanvas
    if (config.GetSyncSettings().enableSelectionHighlight) {
        if (config.GetDebugSettings().enableSyncLogging) {
            LOG_INFO("Sync", "Hierarchy → Scene: Calling treeVis->SetSelectedNode()");
        }
        treeVis->SetSelectedNode(selectedNode);
    }
 
    // Update properties view
    if (m_propertiesTab) {
        if (selectedNode) {
            // Convert ITreeNode back to Node for properties tab
            auto nodeAdapter = dynamic_cast<const EmberCore::NodeAdapter *>(selectedNode);
            if (nodeAdapter) {
                EmberCore::Node *legacyNode = nodeAdapter->GetWrappedNode();
                if (config.GetDebugSettings().enableSyncLogging) {
                    LOG_INFO("Sync", "Hierarchy → Properties: Updating properties with node: " + legacyNode->GetName());
                }
                m_propertiesTab->SetSelectedNode(legacyNode);
            }
        } else {
            if (config.GetDebugSettings().enableSyncLogging) {
                LOG_INFO("Sync", "Hierarchy → Properties: Clearing properties selection");
            }
            m_propertiesTab->ClearSelection();
        }
    }
 
    if (config.GetDebugSettings().enableSyncLogging) {
        LOG_INFO("Sync", "Hierarchy → Scene: Sync operations completed");
    }
 
    // Clear flag
    m_isUpdatingFromHierarchy = false;
}
 
void MainFrame::OnSceneSelectionChanged(EmberCore::ITreeNode *selectedNode) {
    // Check if scene → hierarchy sync is enabled
    auto &config = EmberCore::BehaviorTreeConfigManager::GetInstance().GetConfig();
    if (!config.GetSyncSettings().enableSceneToHierarchy) {
        if (config.GetDebugSettings().enableSyncLogging) {
            LOG_INFO("Sync", "Scene → Hierarchy: Disabled by configuration");
        }
        return;
    }
 
    // Prevent infinite loops
    if (m_isUpdatingFromHierarchy) {
        if (config.GetDebugSettings().enableSyncLogging) {
            LOG_INFO("Sync", "Scene → Hierarchy: Skipped (already updating from hierarchy)");
        }
        return;
    }
 
    // Debug logging
    if (config.GetDebugSettings().enableSyncLogging) {
        LOG_INFO("Sync", "Scene → Hierarchy: Node selected in scene view");
    }
 
    // Set flag to prevent loops
    m_isUpdatingFromScene = true;
 
    if (!m_navigatorTab) {
        m_isUpdatingFromScene = false;
        return;
    }
 
    // Update Navigator hierarchy selection
    if (selectedNode) {
        m_navigatorTab->SelectNodeById(selectedNode->GetId());
    }
 
    // Update properties view
    EmberCore::Node *legacyNode = nullptr;
    if (selectedNode) {
        auto nodeAdapter = dynamic_cast<const EmberCore::NodeAdapter *>(selectedNode);
        if (nodeAdapter)
            legacyNode = nodeAdapter->GetWrappedNode();
    }
    if (m_propertiesTab) {
        if (legacyNode) {
            LOG_INFO("Sync", "Scene → Properties: Updating properties with node: " + legacyNode->GetName());
            m_propertiesTab->SetSelectedNode(legacyNode);
        } else {
            LOG_INFO("Sync", "Scene → Properties: Clearing properties selection");
            m_propertiesTab->ClearSelection();
        }
    }
 
    // Clear flag
    m_isUpdatingFromScene = false;
}
 
void MainFrame::OnPropertiesTabClosed() {
    LOG_INFO("MainFrame", "PropertiesTab is being closed, nullifying pointer");
    m_propertiesTab = nullptr;
}
 
void MainFrame::UpdateNavigatorTabReference(ForgeNavigatorTab *navigatorTab) {
    m_navigatorTab = navigatorTab;
 
    if (m_navigatorTab) {
        if (!m_projectTrees.empty()) {
            m_navigatorTab->SetMainTreeId(m_mainTreeName);
            m_navigatorTab->UpdateTreeList(m_projectTrees, m_currentTreeId);
        }
 
        if (!m_projectBlackboards.empty()) {
            m_navigatorTab->SetBlackboards(m_projectBlackboards);
        }
 
        if (m_scenePanel) {
            IScene *activeScene = m_scenePanel->GetActiveScene();
            if (activeScene && activeScene->GetSceneType() == "BehaviorTree") {
                auto *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
                if (btScene) {
                    auto adapter = btScene->GetTreeAdapter();
                    if (adapter) {
                        m_navigatorTab->SetActiveTree(adapter, m_currentTreeId);
                    }
                }
            }
        }
 
        LOG_INFO("MainFrame", "Navigator tab reference updated and wired");
    }
}
 
void MainFrame::NavigateToBlackboard(const std::string &bbId) {
    if (m_scenePanel && m_blackboardScene) {
        for (size_t i = 0; i < m_scenePanel->GetSceneCount(); ++i) {
            if (m_scenePanel->GetScene(static_cast<int>(i)) == m_blackboardScene) {
                m_scenePanel->SetActiveScene(static_cast<int>(i));
                break;
            }
        }
        m_blackboardScene->ScrollToBlackboard(bbId);
    }
}
 
void MainFrame::OnNavigatorTabClosed() {
    LOG_INFO("MainFrame", "NavigatorTab is being closed, nullifying pointer");
    m_navigatorTab = nullptr;
}
 
std::shared_ptr<EmberCore::Node> MainFrame::GetSharedBehaviorTree() const {
    if (!m_scenePanel) {
        return nullptr;
    }
 
    // Get the active scene
    IScene *activeScene = m_scenePanel->GetActiveScene();
    if (!activeScene || activeScene->GetSceneType() != "BehaviorTree") {
        return nullptr;
    }
 
    // Cast to BehaviorTreeScene to access the behavior tree
    BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
    if (!btScene) {
        return nullptr;
    }
 
    // Get the behavior tree root and wrap in shared_ptr
    EmberCore::Node *rawTree = btScene->GetBehaviorTree();
    if (!rawTree) {
        return nullptr;
    }
 
    // Return as shared_ptr (the scene owns it, so we use a non-owning shared_ptr)
    return std::shared_ptr<EmberCore::Node>(rawTree, [](EmberCore::Node *) {});
}
 
void MainFrame::UpdatePropertiesTabReference(PropertiesTab *propertiesTab) {
    m_propertiesTab = propertiesTab;
 
    // If we have a properties tab, set the currently selected node (if any)
    if (m_propertiesTab && m_scenePanel) {
        IScene *activeScene = m_scenePanel->GetActiveScene();
        if (activeScene && activeScene->GetSceneType() == "BehaviorTree") {
            BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
            if (btScene) {
                auto *treeVis = btScene->GetTreeVisualization();
                if (treeVis) {
                    EmberCore::ITreeNode *selectedNode = treeVis->GetSelectedNode();
                    if (selectedNode) {
                        // Convert ITreeNode to Node for properties tab
                        auto nodeAdapter = dynamic_cast<const EmberCore::NodeAdapter *>(selectedNode);
                        if (nodeAdapter) {
                            EmberCore::Node *legacyNode = nodeAdapter->GetWrappedNode();
                            m_propertiesTab->SetSelectedNode(legacyNode);
                            LOG_INFO("MainFrame", "Set selected node on newly created properties tab");
                        }
                    }
                }
            }
        }
    }
}
 
void MainFrame::CenterOnNode(EmberCore::ITreeNode *node) {
    // Safety checks: Ensure scene panel and node are valid
    if (!m_scenePanel || !node) {
        return;
    }
 
    // Get the active scene and check if it's a behavior tree scene
    IScene *activeScene = m_scenePanel->GetActiveScene();
    if (!activeScene || activeScene->GetSceneType() != "BehaviorTree") {
        return;
    }
 
    // Cast to BehaviorTreeScene to access tree visualization
    BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
    if (!btScene) {
        return;
    }
 
    auto *treeVis = btScene->GetTreeVisualization();
    if (!treeVis) {
        return;
    }
 
    // Additional safety: Check if the scene's panel is still valid
    wxPanel *scenePanel = btScene->GetPanel();
    if (!scenePanel || !scenePanel->IsShown()) {
        return;
    }
 
    // Center the view on the selected node
    treeVis->CenterOnNode(node);
}
 
void MainFrame::InvalidateCanvasLayout() {
    if (!m_scenePanel)
        return;
 
    IScene *activeScene = m_scenePanel->GetActiveScene();
    if (!activeScene || activeScene->GetSceneType() != "BehaviorTree")
        return;
 
    auto *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
    if (!btScene)
        return;
 
    auto *treeVis = btScene->GetTreeVisualization();
    if (treeVis) {
        treeVis->InvalidateLayout();
    }
}
 
void MainFrame::RefreshHierarchyTree() {
    if (m_navigatorTab) {
        m_navigatorTab->RefreshHierarchy();
    }
}
 
void MainFrame::SyncSelection(EmberCore::ITreeNode *selectedNode) {
    // Prevent infinite loops between views
    static bool updating = false;
    if (updating) {
        LOG_INFO("Sync", "SyncSelection: Prevented infinite loop");
        return;
    }
    updating = true;
 
    LOG_INFO("Sync", "SyncSelection: Synchronizing selection to: " + (selectedNode ? selectedNode->GetName() : "null"));
 
    if (m_navigatorTab && selectedNode) {
        m_navigatorTab->SelectNodeById(selectedNode->GetId());
    }
 
    // Update properties view
    if (m_propertiesTab) {
        if (selectedNode) {
            // Convert ITreeNode back to Node for properties tab
            auto nodeAdapter = dynamic_cast<const EmberCore::NodeAdapter *>(selectedNode);
            if (nodeAdapter) {
                EmberCore::Node *legacyNode = nodeAdapter->GetWrappedNode();
                LOG_INFO("Sync", "SyncSelection: Updating properties with node: " + legacyNode->GetName());
                m_propertiesTab->SetSelectedNode(legacyNode);
            }
        } else {
            LOG_INFO("Sync", "SyncSelection: Clearing properties selection");
            m_propertiesTab->ClearSelection();
        }
    }
 
    // Update scene view
    if (m_scenePanel) {
        IScene *activeScene = m_scenePanel->GetActiveScene();
        if (activeScene && activeScene->GetSceneType() == "BehaviorTree") {
            BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(activeScene);
            if (btScene && btScene->GetTreeVisualization()) {
                LOG_INFO("Sync", "SyncSelection: Updating scene view");
                btScene->GetTreeVisualization()->SetSelectedNode(selectedNode);
            }
        }
    }
 
    updating = false;
    LOG_INFO("Sync", "SyncSelection: Synchronization completed");
}
 
// ============================================================================
// Project Operations
// ============================================================================
 
void MainFrame::OnNewProject(wxCommandEvent &event) { NewProject(); }
 
void MainFrame::OnOpenProject(wxCommandEvent &event) { OpenProject(); }
 
void MainFrame::OnCloseProject(wxCommandEvent &event) { CloseProject(); }
 
void MainFrame::OnSaveProject(wxCommandEvent &event) { SaveProject(); }
 
void MainFrame::OnProjectSettings(wxCommandEvent &event) {
    LOG_INFO("Menu", "OnProjectSettings called");
    ShowProjectSettings();
}
 
void MainFrame::NewProject() {
    LOG_INFO("Project", "Creating new project...");
 
    BehaviorTreeProjectDialog dialog(this, nullptr);
    int result = dialog.ShowModal();
 
    if (result == wxID_OK) {
        auto project = dialog.GetProject();
        if (project) {
            // Get default my_projects directory
            wxString defaultProjectsDir = EmberForge::ResourcePath::GetDir("my_projects");
 
            // Create directory if it doesn't exist
            if (!wxFileName::DirExists(defaultProjectsDir)) {
                wxFileName::Mkdir(defaultProjectsDir, wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
            }
 
            // Ask where to save the project
            wxFileDialog saveDialog(this, "Save BehaviorTree Project", defaultProjectsDir,
                                    wxString::FromUTF8(project->GetName()) + ".btproj",
                                    "BehaviorTree Project (*.btproj)|*.btproj", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 
            if (saveDialog.ShowModal() == wxID_OK) {
                wxString projectPath = saveDialog.GetPath();
                project->SetProjectFilePath(projectPath.ToStdString());
 
                if (project->SaveToFile(projectPath.ToStdString())) {
                    m_activeProject = project;
 
                    // Add to recent projects
                    auto &projectManager = EmberCore::ProjectManager::GetInstance();
                    projectManager.AddToRecentProjects(projectPath.ToStdString());
 
                    // Parse and load the project
                    OpenProject(projectPath);
 
                    LOG_INFO("Project", "Project created and saved: " + projectPath.ToStdString());
                    SetStatusText("Project created: " + wxString::FromUTF8(project->GetName()));
                } else {
                    wxMessageBox("Failed to save project file.", "Error", wxOK | wxICON_ERROR, this);
                    LOG_ERROR("Project", "Failed to save project file");
                }
            }
        }
    }
}
 
void MainFrame::OpenProject() {
    LOG_INFO("Project", "Opening project dialog...");
 
    ProjectManagerDialog dialog(this);
    int result = dialog.ShowModal();
 
    if (result == wxID_OK && dialog.HasSelectedProject()) {
        OpenProject(dialog.GetSelectedProjectPath());
    }
}
 
void MainFrame::OpenProject(const wxString &projectPath) {
    LOG_INFO("Project", "Opening project: " + projectPath.ToStdString());
 
    // Load the project
    auto project = std::make_shared<EmberCore::BehaviorTreeProject>();
    if (!project->LoadFromFile(projectPath.ToStdString())) {
        wxMessageBox("Failed to load project file.", "Error", wxOK | wxICON_ERROR, this);
        LOG_ERROR("Project", "Failed to load project from: " + projectPath.ToStdString());
        return;
    }
 
    // Close any existing project
    if (m_activeProject) {
        CloseProject();
    }
 
    m_activeProject = project;
 
    // Add to recent projects
    auto &projectManager = EmberCore::ProjectManager::GetInstance();
    projectManager.AddToRecentProjects(projectPath.ToStdString());
 
    // Get the parser profile
    auto &configManager = EmberCore::ConfigManager::GetInstance();
    auto profile = configManager.GetProfile(project->GetParserProfileName());
    if (!profile) {
        profile = configManager.GetActiveProfile();
    }
 
    // Create parser and parse project files
    EmberCore::LibXMLBehaviorTreeParser parser(profile->GetConfig());
 
    // Show loading dialog
    LoadingDialog loadingDialog(this, "Loading Project: " + wxString::FromUTF8(project->GetName()));
    loadingDialog.Show();
    wxYield();
 
    // Progress callback to forward parser progress to the dialog
    class ProjectProgressCallback : public EmberCore::IParseProgressCallback {
      private:
        LoadingDialog *dialog_;
 
      public:
        explicit ProjectProgressCallback(LoadingDialog *dialog) : dialog_(dialog) {}
 
        bool OnProgress(const EmberCore::String &message, int current, int total) override {
            if (dialog_) {
                bool shouldContinue = dialog_->UpdateProgress(current, total, message);
                wxMilliSleep(30); // Small delay to make progress visible
                return shouldContinue;
            }
            return true;
        }
    };
 
    ProjectProgressCallback progressCallback(&loadingDialog);
    parser.SetProgressCallback(&progressCallback);
 
    // Log project information before parsing
    loadingDialog.AppendLog("Project: " + wxString::FromUTF8(project->GetName()), "[INFO]");
    loadingDialog.AppendLog("Parser Profile: " + wxString::FromUTF8(profile->GetName()), "[INFO]");
    loadingDialog.AppendLog("Resource Files: " + wxString::Format("%zu", project->GetResourceCount()), "[INFO]");
    loadingDialog.AppendLog("", ""); // Blank line
 
    // List files to be parsed
    const auto &resources = project->GetResources();
    for (size_t i = 0; i < resources.size(); ++i) {
        wxFileName fn(wxString::FromUTF8(project->ResolveResourcePath(resources[i])));
        loadingDialog.AppendLog(wxString::Format("  %zu. %s", i + 1, fn.GetFullName()), "[FILE]");
    }
    loadingDialog.AppendLog("", ""); // Blank line
    loadingDialog.AppendLog("Starting parser...", "[INIT]");
    wxYield();
 
    // Parse the project
    auto parseResult = parser.ParseProject(project.get());
 
    // Log per-file parsing results
    loadingDialog.AppendLog("", ""); // Blank line
    loadingDialog.AppendLog("=== Per-File Parsing Results ===", "[INFO]");
 
    int totalTrees = 0;
    int totalBlackboards = 0;
    int totalWarnings = 0;
    int totalErrors = 0;
 
    for (const auto &fileInfo : parseResult.file_infos) {
        wxFileName fn(wxString::FromUTF8(fileInfo.filepath));
        wxString filename = fn.GetFullName();
 
        if (fileInfo.parsed_successfully) {
            loadingDialog.AppendLog(filename + " - Parsed successfully", "[SUCCESS]");
        } else {
            loadingDialog.AppendLog(filename + " - Parse FAILED", "[ERROR]");
        }
 
        // Show trees found
        if (fileInfo.tree_count > 0) {
            wxString treeList;
            for (size_t i = 0; i < fileInfo.tree_ids.size(); ++i) {
                if (i > 0)
                    treeList += ", ";
                treeList += wxString::FromUTF8(fileInfo.tree_ids[i]);
            }
            loadingDialog.AppendLog(wxString::Format("  Trees: %d (%s)", fileInfo.tree_count, treeList), "[INFO]");
            totalTrees += fileInfo.tree_count;
        }
 
        // Show blackboards found
        if (fileInfo.blackboard_count > 0) {
            wxString bbList;
            for (size_t i = 0; i < fileInfo.blackboard_ids.size(); ++i) {
                if (i > 0)
                    bbList += ", ";
                bbList += wxString::FromUTF8(fileInfo.blackboard_ids[i]);
            }
            loadingDialog.AppendLog(wxString::Format("  Blackboards: %d (%s)", fileInfo.blackboard_count, bbList),
                                    "[INFO]");
            totalBlackboards += fileInfo.blackboard_count;
        }
 
        // Show SubTree references
        if (!fileInfo.subtree_refs.empty()) {
            wxString refList;
            for (size_t i = 0; i < fileInfo.subtree_refs.size(); ++i) {
                if (i > 0)
                    refList += ", ";
                refList += wxString::FromUTF8(fileInfo.subtree_refs[i]);
            }
            loadingDialog.AppendLog("  SubTree refs: " + refList, "[INFO]");
        }
 
        // Show warnings
        for (const auto &warning : fileInfo.warnings) {
            loadingDialog.AppendLog("  " + wxString::FromUTF8(warning), "[WARN]");
            totalWarnings++;
        }
 
        // Show errors
        for (const auto &error : fileInfo.errors) {
            loadingDialog.AppendLog("  " + wxString::FromUTF8(error), "[ERROR]");
            totalErrors++;
        }
    }
 
    // Log project-level issues
    if (!parseResult.unimplemented_references.empty()) {
        loadingDialog.AppendLog("", "");
        loadingDialog.AppendLog("=== Unimplemented Tree References ===", "[WARN]");
        for (const auto &ref : parseResult.unimplemented_references) {
            loadingDialog.AppendLog("  " + wxString::FromUTF8(ref), "[WARN]");
        }
    }
 
    if (!parseResult.duplicate_tree_ids.empty()) {
        loadingDialog.AppendLog("", "");
        loadingDialog.AppendLog("=== Duplicate Tree IDs ===", "[WARN]");
        for (const auto &dup : parseResult.duplicate_tree_ids) {
            loadingDialog.AppendLog("  " + wxString::FromUTF8(dup), "[WARN]");
        }
    }
 
    if (!parseResult.duplicate_blackboard_ids.empty()) {
        loadingDialog.AppendLog("", "");
        loadingDialog.AppendLog("=== Duplicate Blackboard IDs ===", "[WARN]");
        for (const auto &dup : parseResult.duplicate_blackboard_ids) {
            loadingDialog.AppendLog("  " + wxString::FromUTF8(dup), "[WARN]");
        }
    }
 
    if (!parseResult.unresolved_blackboard_includes.empty()) {
        loadingDialog.AppendLog("", "");
        loadingDialog.AppendLog("=== Unresolved Blackboard Includes ===", "[WARN]");
        for (const auto &unres : parseResult.unresolved_blackboard_includes) {
            loadingDialog.AppendLog("  " + wxString::FromUTF8(unres), "[WARN]");
        }
    }
 
    // Summary
    loadingDialog.AppendLog("", "");
    loadingDialog.AppendLog("=== Summary ===", "[INFO]");
    loadingDialog.AppendLog(wxString::Format("Files parsed: %zu", parseResult.file_infos.size()), "[INFO]");
    loadingDialog.AppendLog(wxString::Format("Total trees: %d", totalTrees), "[INFO]");
    loadingDialog.AppendLog(wxString::Format("Total blackboards: %d", totalBlackboards), "[INFO]");
    if (totalWarnings > 0) {
        loadingDialog.AppendLog(wxString::Format("Warnings: %d", totalWarnings), "[WARN]");
    }
    if (totalErrors > 0) {
        loadingDialog.AppendLog(wxString::Format("Errors: %d", totalErrors), "[ERROR]");
    }
 
    wxYield();
 
    if (parseResult.success) {
        // Update project with tree statuses
        project->SetTreeImplementationStatus(parseResult.tree_statuses);
 
        // Store ALL parsed trees (not just main)
        m_projectTrees = parseResult.parsed_trees;
        m_mainTreeName = parseResult.main_tree_name;
 
        // Store blackboard data
        m_projectBlackboards = parseResult.parsed_blackboards;
        m_blackboardIncludesMap = parseResult.blackboard_includes_map;
 
        // Create the non-closable BlackboardScene at tab 0
        if (m_scenePanel && !m_projectBlackboards.empty()) {
            auto bbScene = std::make_unique<BlackboardScene>(m_scenePanel->GetNotebook());
            bbScene->SetBlackboards(m_projectBlackboards, m_blackboardIncludesMap);
            m_blackboardScene = bbScene.get();
            m_scenePanel->InsertScene(0, std::move(bbScene));
        }
 
        // Pass blackboards to navigator
        if (m_navigatorTab && !m_projectBlackboards.empty()) {
            m_navigatorTab->SetBlackboards(m_projectBlackboards);
        }
 
        // Check if there's a valid main tree entry point
        bool hasMainTreeEntryPoint = !parseResult.main_tree_name.empty() &&
                                     m_projectTrees.find(parseResult.main_tree_name) != m_projectTrees.end();
 
        if (hasMainTreeEntryPoint) {
            // Found main tree entry point - load it normally
            LOG_INFO("Project", "Found main tree entry point: " + parseResult.main_tree_name);
            loadingDialog.AppendLog("Main tree: " + wxString::FromUTF8(parseResult.main_tree_name), "[INFO]");
            LoadTreeIntoScene(parseResult.main_tree_name);
        } else if (!m_projectTrees.empty()) {
            // No main tree entry point found
            // FIXED: Skip expensive overview scene creation for large projects (>20 trees)
            // Instead, user can select trees from the dropdown
            if (m_projectTrees.size() > 20) {
                LOG_INFO("Project", "No main tree entry point found - project has " +
                                        std::to_string(m_projectTrees.size()) +
                                        " trees. Use tree selector to view individual trees.");
                loadingDialog.AppendLog("No main tree - loading first tree", "[INFO]");
 
                // Load the first tree as a starting point
                if (!m_projectTrees.empty()) {
                    LoadTreeIntoScene(m_projectTrees.begin()->first);
                }
            } else {
                // Small project - create overview scene with all trees side-by-side
                LOG_INFO("Project", "No main tree entry point found - creating project overview with all trees");
                loadingDialog.AppendLog("No main tree - creating project overview", "[INFO]");
                CreateProjectOverviewScene();
            }
        }
 
        // Update tree selector dropdown
        UpdateTreeSelector();
 
        if (m_scenePanel)
            m_scenePanel->ShowScenes();
 
        loadingDialog.AppendLog("", "");
        loadingDialog.AppendLog("Project loaded successfully!", "[COMPLETE]");
        loadingDialog.UpdateProgress(100, 100, "Project loaded successfully");
        wxYield();
 
        loadingDialog.MarkComplete();
 
        LOG_INFO("Project", "Project loaded successfully: " + project->GetName() + " with " +
                                std::to_string(m_projectTrees.size()) + " trees");
        SetStatusText("Project: " + wxString::FromUTF8(project->GetName()) + " (" +
                      wxString::Format("%zu", m_projectTrees.size()) + " trees)");
 
        loadingDialog.ShowModal();
    } else {
        // Mark as complete even on error so user can review logs
        loadingDialog.AppendLog("Project parsing failed", "[ERROR]");
 
        wxString errorMsg = "Failed to parse project files:\n\n";
        for (const auto &err : parseResult.errors) {
            errorMsg += "- " + wxString::FromUTF8(err.message) + "\n";
        }
 
        // Log errors to the dialog
        for (const auto &err : parseResult.errors) {
            loadingDialog.AppendLog(wxString::FromUTF8(err.message), "[ERROR]");
        }
 
        loadingDialog.MarkComplete();
 
        LOG_ERROR("Project", "Failed to parse project files");
 
        // Keep dialog open until user closes it
        loadingDialog.ShowModal();
 
        wxMessageBox(errorMsg, "Error", wxOK | wxICON_ERROR, this);
 
        m_activeProject = nullptr;
        m_projectTrees.clear();
        m_currentTreeId.clear();
    }
}
 
void MainFrame::LoadTreeIntoScene(const std::string &treeId) {
    if (m_projectTrees.find(treeId) == m_projectTrees.end()) {
        LOG_WARNING("MainFrame", "Tree not found: " + treeId);
        return;
    }
 
    auto tree = m_projectTrees[treeId];
    m_currentTreeId = treeId;
 
    if (!tree || !m_scenePanel)
        return;
 
    IScene *scene = m_scenePanel->GetActiveScene();
    BehaviorTreeScene *btScene = nullptr;
 
    if (scene && scene->GetSceneType() == "BehaviorTree") {
        btScene = dynamic_cast<BehaviorTreeScene *>(scene);
    }
 
    if (!btScene) {
        int idx = m_scenePanel->CreateNewScene(wxString::FromUTF8(treeId));
        if (idx < 0)
            return;
        scene = m_scenePanel->GetScene(idx);
        if (scene && scene->GetSceneType() == "BehaviorTree") {
            btScene = dynamic_cast<BehaviorTreeScene *>(scene);
            if (btScene) {
                btScene->SetNodeSelectionCallback(
                    [this](EmberCore::ITreeNode *node) { OnSceneSelectionChanged(node); });
                if (auto *treeVis = btScene->GetTreeVisualization()) {
                    treeVis->SetVisibilityChangeCallback([this]() { RefreshHierarchyTree(); });
                }
            }
        }
    }
 
    if (!btScene)
        return;
 
    EmberCore::Node *rootNodePtr = tree->GetRootNode();
    if (rootNodePtr) {
        std::shared_ptr<EmberCore::Node> rootNode(tree, rootNodePtr);
        btScene->SetBehaviorTree(rootNode);
 
        if (m_navigatorTab) {
            auto adapter = btScene->GetTreeAdapter();
            if (adapter) {
                m_navigatorTab->SetActiveTree(adapter, treeId);
            }
        }
 
        SetStatusText("Viewing tree: " + wxString::FromUTF8(treeId));
        LOG_INFO("MainFrame", "Loaded tree into scene: " + treeId);
    }
}
 
bool MainFrame::IsActiveSceneBehaviorTree() const {
    if (!m_scenePanel)
        return false;
    IScene *scene = m_scenePanel->GetActiveScene();
    return scene && scene->GetSceneType() == "BehaviorTree";
}
 
void MainFrame::OpenTreeInNewScene(const std::string &treeId) {
    if (m_projectTrees.find(treeId) == m_projectTrees.end()) {
        LOG_WARNING("MainFrame", "Tree not found: " + treeId);
        return;
    }
 
    if (!m_scenePanel) {
        LOG_ERROR("MainFrame", "Scene panel not available");
        return;
    }
 
    auto tree = m_projectTrees[treeId];
    if (!tree)
        return;
 
    int sceneIdx = m_scenePanel->CreateNewScene(wxString::FromUTF8(treeId));
    if (sceneIdx < 0)
        return;
 
    IScene *scene = m_scenePanel->GetScene(sceneIdx);
    if (!scene || scene->GetSceneType() != "BehaviorTree")
        return;
 
    BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(scene);
    if (!btScene)
        return;
 
    EmberCore::Node *rootNodePtr = tree->GetRootNode();
    if (rootNodePtr) {
        std::shared_ptr<EmberCore::Node> rootNode(tree, rootNodePtr);
        btScene->SetBehaviorTree(rootNode);
 
        btScene->SetNodeSelectionCallback([this](EmberCore::ITreeNode *node) { OnSceneSelectionChanged(node); });
 
        if (auto *treeVis = btScene->GetTreeVisualization()) {
            treeVis->SetVisibilityChangeCallback([this]() { RefreshHierarchyTree(); });
        }
    }
 
    m_scenePanel->SetActiveScene(sceneIdx);
    m_currentTreeId = treeId;
    UpdateTreeSelector();
    SetStatusText("Viewing tree: " + wxString::FromUTF8(treeId));
    LOG_INFO("MainFrame", "Opened tree '" + treeId + "' in new scene");
}
 
void MainFrame::CreateProjectOverviewScene() {
    if (!m_scenePanel || m_projectTrees.empty()) {
        return;
    }
 
    LOG_INFO("MainFrame", "Creating project overview scene with " + std::to_string(m_projectTrees.size()) + " trees");
 
    IScene *scene = m_scenePanel->GetActiveScene();
    BehaviorTreeScene *btScene = nullptr;
 
    if (scene && scene->GetSceneType() == "BehaviorTree") {
        btScene = dynamic_cast<BehaviorTreeScene *>(scene);
    }
 
    if (!btScene) {
        int idx = m_scenePanel->CreateNewScene("Project Overview");
        if (idx < 0)
            return;
        scene = m_scenePanel->GetScene(idx);
        if (scene && scene->GetSceneType() == "BehaviorTree")
            btScene = dynamic_cast<BehaviorTreeScene *>(scene);
    }
 
    if (!btScene) {
        return;
    }
 
    auto *treeVis = btScene->GetTreeVisualization();
    if (!treeVis) {
        return;
    }
 
    // Create a scrolled window to hold all trees
    wxScrolled<wxPanel> *overviewPanel = new wxScrolled<wxPanel>(btScene->GetPanel(), wxID_ANY);
    overviewPanel->SetBackgroundColour(wxColour(45, 45, 50));
    overviewPanel->SetScrollRate(20, 20);
 
    // Use horizontal box sizer to arrange trees side-by-side
    wxBoxSizer *horizontalSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Create a tree visualization for each tree
    size_t treeIndex = 0;
    for (const auto &pair : m_projectTrees) {
        const std::string &treeId = pair.first;
        auto tree = pair.second;
 
        EmberCore::Node *rootNodePtr = tree->GetRootNode();
        if (!rootNodePtr) {
            continue;
        }
 
        // Create a panel for this tree
        wxPanel *treePanel = new wxPanel(overviewPanel, wxID_ANY);
        treePanel->SetBackgroundColour(wxColour(45, 45, 50));
        wxBoxSizer *treeSizer = new wxBoxSizer(wxVERTICAL);
 
        // Add tree label
        wxStaticText *label = new wxStaticText(treePanel, wxID_ANY, wxString::FromUTF8(treeId));
        wxFont labelFont = label->GetFont();
        labelFont.SetPointSize(labelFont.GetPointSize() + 2);
        labelFont.MakeBold();
        label->SetFont(labelFont);
        label->SetForegroundColour(wxColour(200, 200, 200));
        treeSizer->Add(label, 0, wxALL | wxALIGN_CENTER, 10);
 
        auto *vis = new EmberForge::ForgeTreeCanvas(treePanel);
        vis->SetMinSize(wxSize(600, 400));
 
        auto behaviorTree = std::make_shared<EmberCore::BehaviorTree>(treeId);
        std::shared_ptr<EmberCore::Node> rootNode(tree, rootNodePtr);
        behaviorTree->SetRootNode(rootNode);
        auto treeAdapter = std::make_shared<EmberCore::DirectTreeAdapter>(behaviorTree);
        vis->SetTree(treeAdapter);
 
        treeSizer->Add(vis, 1, wxEXPAND | wxALL, 5);
        treePanel->SetSizer(treeSizer);
 
        // Add to horizontal layout with separator
        horizontalSizer->Add(treePanel, 0, wxEXPAND | wxALL, 10);
 
        if (treeIndex < m_projectTrees.size() - 1) {
            // Add vertical separator line
            wxPanel *separator = new wxPanel(overviewPanel, wxID_ANY, wxDefaultPosition, wxSize(2, -1));
            separator->SetBackgroundColour(wxColour(80, 80, 85));
            horizontalSizer->Add(separator, 0, wxEXPAND | wxTOP | wxBOTTOM, 10);
        }
 
        treeIndex++;
    }
 
    overviewPanel->SetSizer(horizontalSizer);
    overviewPanel->FitInside(); // Adjust scrollbar
 
    // Replace the tree visualization with the overview panel
    wxSizer *panelSizer = btScene->GetPanel()->GetSizer();
    if (panelSizer) {
        panelSizer->Clear(false); // Don't delete children yet
        panelSizer->Add(overviewPanel, 1, wxEXPAND | wxALL, 5);
        btScene->GetPanel()->Layout();
    }
 
    SetStatusText("Project Overview: " + wxString::Format("%zu trees", m_projectTrees.size()));
    LOG_INFO("MainFrame", "Project overview scene created successfully");
}
 
void MainFrame::UpdateTreeSelector() {
    if (m_navigatorTab) {
        m_navigatorTab->SetMainTreeId(m_mainTreeName);
        m_navigatorTab->UpdateTreeList(m_projectTrees, m_currentTreeId);
    }
}
 
void MainFrame::CloseProject() {
    if (!m_activeProject) {
        LOG_INFO("Project", "No project to close");
        return;
    }
 
    LOG_INFO("Project", "Closing project: " + m_activeProject->GetName());
 
    // TODO: Check for unsaved changes and prompt
 
    // Clear the scene and tree selector
    if (m_scenePanel) {
        IScene *scene = m_scenePanel->GetActiveScene();
        if (scene && scene->GetSceneType() == "BehaviorTree") {
            BehaviorTreeScene *btScene = dynamic_cast<BehaviorTreeScene *>(scene);
            if (btScene) {
                btScene->SetBehaviorTree(std::shared_ptr<EmberCore::Node>(nullptr)); // Clear the tree from the scene
 
                auto *treeViz = btScene->GetTreeVisualization();
                if (treeViz) {
                    treeViz->SetTree(nullptr);
                    treeViz->RefreshCanvas();
                }
            }
        }
    }
 
    // Clear the properties tab
    if (m_propertiesTab) {
        m_propertiesTab->ClearSelection();
    }
 
    // Clear navigator tab
    if (m_navigatorTab) {
        m_navigatorTab->ClearTreeList();
    }
 
    // Remove the blackboard scene if it exists
    if (m_scenePanel && m_blackboardScene) {
        for (size_t i = 0; i < m_scenePanel->GetSceneCount(); ++i) {
            if (m_scenePanel->GetScene(static_cast<int>(i)) == m_blackboardScene) {
                m_scenePanel->RemoveScene(static_cast<int>(i));
                break;
            }
        }
        m_blackboardScene = nullptr;
    }
 
    // Clear tree data
    m_activeProject = nullptr;
    m_projectTrees.clear();
    m_projectBlackboards.clear();
    m_blackboardIncludesMap.clear();
    m_currentTreeId.clear();
    m_mainTreeName.clear();
 
    // Force-remove all remaining scenes without unsaved-changes prompts
    if (m_scenePanel) {
        while (m_scenePanel->GetSceneCount() > 0) {
            m_scenePanel->RemoveScene(0, true);
        }
        m_scenePanel->ShowWelcome();
    }
 
    SetStatusText("Project closed");
}
 
void MainFrame::SaveProject() {
    if (!m_activeProject) {
        wxMessageBox("No project is currently open.", "Information", wxOK | wxICON_INFORMATION, this);
        return;
    }
 
    wxString projectPath = wxString::FromUTF8(m_activeProject->GetProjectFilePath());
 
    if (projectPath.IsEmpty()) {
        // Need to choose a save location
        wxFileDialog saveDialog(this, "Save BehaviorTree Project", "",
                                wxString::FromUTF8(m_activeProject->GetName()) + ".btproj",
                                "BehaviorTree Project (*.btproj)|*.btproj", wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
 
        if (saveDialog.ShowModal() != wxID_OK) {
            return;
        }
 
        projectPath = saveDialog.GetPath();
    }
 
    if (m_activeProject->SaveToFile(projectPath.ToStdString())) {
        LOG_INFO("Project", "Project saved: " + projectPath.ToStdString());
        SetStatusText("Project saved");
    } else {
        wxMessageBox("Failed to save project.", "Error", wxOK | wxICON_ERROR, this);
        LOG_ERROR("Project", "Failed to save project");
    }
}
 
void MainFrame::ShowProjectSettings() {
    if (!m_activeProject) {
        wxMessageBox("No project is currently open.", "Information", wxOK | wxICON_INFORMATION, this);
        return;
    }
 
    BehaviorTreeProjectDialog dialog(this, m_activeProject);
    int result = dialog.ShowModal();
 
    if (result == wxID_OK) {
        // Project settings may have changed
        SaveProject();
        LOG_INFO("Project", "Project settings updated");
        SetStatusText("Project settings saved");
    }
}
 
bool MainFrame::HasActiveProject() const { return m_activeProject != nullptr; }
 
std::shared_ptr<EmberCore::BehaviorTreeProject> MainFrame::GetActiveProject() const { return m_activeProject; }