FileExplorerTab.cpp

Go to the documentation of this file.

#include "Tabs/FileExplorerTab.h"
#include "Utils/AppPreferences.h"
#include "Utils/Logger.h"
#include "Utils/ResourcePath.h"
#include <algorithm>
#include <functional>
#include <limits>
#include <vector>
#include <wx/artprov.h>
#include <wx/bmpbuttn.h>
#include <wx/button.h>
#include <wx/dnd.h>
#include <wx/popupwin.h>
#include <wx/sizer.h>
#include <wx/statbmp.h>
#include <wx/statline.h>
#include <wx/stattext.h>
#include <wx/stdpaths.h>
#include <wx/tglbtn.h>
 
// ============================================================================
// ICON CUSTOMIZATION GUIDE
// ============================================================================
// To replace built-in icons with custom ones:
// 1. Place your custom PNG icons in: resources/icons/
// 2. Modify LoadGridIcon() and LoadTreeIcon() methods below
// 3. Example icon names: folder.png, file.png, xml.png, png.png, json.png
// 4. Recommended sizes: Grid icons 96x96, Tree icons 16x16
// ============================================================================
 
// Custom tree item data to store file paths
class FileTreeItemData : public wxTreeItemData {
  public:
    FileTreeItemData(const wxString &path, bool isDir) : m_path(path), m_isDirectory(isDir) {}
 
    wxString GetPath() const { return m_path; }
    bool IsDirectory() const { return m_isDirectory; }
 
  private:
    wxString m_path;
    bool m_isDirectory;
};
 
// ============================================================================
// Navigation History Popup Window
// ============================================================================
 
class HistoryPopup : public wxPopupTransientWindow {
  public:
    HistoryPopup(wxWindow *parent, const std::vector<wxString> &backStack, const std::vector<wxString> &forwardStack,
                 const wxString &currentPath, std::function<void(const wxString &)> onNavigate)
        : wxPopupTransientWindow(parent, wxBORDER_SIMPLE), m_onNavigate(onNavigate),
          m_hoveredIndex(std::numeric_limits<size_t>::max()) {
        SetBackgroundColour(wxColour(45, 45, 45));
 
        wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
        // Build items list (back stack reversed + current + forward stack)
        // Back stack (most recent first)
        for (int i = backStack.size() - 1; i >= 0; i--) {
            if (m_items.size() >= 15)
                break;
            m_items.push_back({backStack[i], ItemType::BACK});
        }
 
        // Current location
        m_items.push_back({currentPath, ItemType::CURRENT});
        size_t currentIndex = m_items.size() - 1;
 
        // Forward stack (in order)
        for (size_t i = 0; i < forwardStack.size() && m_items.size() < 15; i++) {
            m_items.push_back({forwardStack[forwardStack.size() - 1 - i], ItemType::FORWARD});
        }
 
        // Create scrolled window for items
        wxScrolledWindow *scrollWin = new wxScrolledWindow(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL);
        scrollWin->SetScrollRate(0, 10);
        scrollWin->SetBackgroundColour(wxColour(45, 45, 45));
 
        wxBoxSizer *itemsSizer = new wxBoxSizer(wxVERTICAL);
 
        // Add header
        wxStaticText *header = new wxStaticText(scrollWin, wxID_ANY, "Navigation History");
        header->SetForegroundColour(wxColour(220, 220, 220));
        wxFont headerFont = header->GetFont();
        headerFont.SetWeight(wxFONTWEIGHT_BOLD);
        headerFont.SetPointSize(headerFont.GetPointSize() + 1);
        header->SetFont(headerFont);
        itemsSizer->Add(header, 0, wxALL | wxALIGN_CENTER, 8);
 
        // Add separator
        wxStaticLine *separator = new wxStaticLine(scrollWin, wxID_ANY);
        itemsSizer->Add(separator, 0, wxEXPAND | wxLEFT | wxRIGHT, 5);
 
        // Add items
        for (size_t i = 0; i < m_items.size(); i++) {
            wxPanel *itemPanel = CreateHistoryItem(scrollWin, m_items[i], i, i == currentIndex);
            itemsSizer->Add(itemPanel, 0, wxEXPAND);
        }
 
        scrollWin->SetSizer(itemsSizer);
        scrollWin->SetMinSize(wxSize(400, 200));
        mainSizer->Add(scrollWin, 1, wxEXPAND);
 
        SetSizer(mainSizer);
 
        // Force layout before calculating size
        Layout();
 
        // Calculate size based on content (larger size for better visibility)
        wxSize bestSize = scrollWin->GetBestSize();
        int width = wxMax(400, wxMin(500, bestSize.GetWidth() + 40));
        int height = wxMax(250, wxMin(500, bestSize.GetHeight() + 40));
 
        SetClientSize(wxSize(width, height));
    }
 
  private:
    enum class ItemType { BACK, CURRENT, FORWARD };
 
    struct HistoryItem {
        wxString path;
        ItemType type;
    };
 
    wxPanel *CreateHistoryItem(wxWindow *parent, const HistoryItem &item, size_t index, bool isCurrent) {
        wxPanel *panel = new wxPanel(parent, wxID_ANY);
        panel->SetBackgroundColour(isCurrent ? wxColour(70, 100, 140) : wxColour(45, 45, 45));
        panel->SetMinSize(wxSize(380, 40)); // Larger size for better visibility
 
        wxBoxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
 
        // Add icon based on type
        wxString icon;
        if (item.type == ItemType::BACK)
            icon = "  ← ";
        else if (item.type == ItemType::FORWARD)
            icon = "  → ";
        else
            icon = "  • ";
 
        wxStaticText *iconText = new wxStaticText(panel, wxID_ANY, icon);
        iconText->SetForegroundColour(wxColour(150, 150, 150));
        wxFont iconFont = iconText->GetFont();
        iconFont.SetPointSize(iconFont.GetPointSize() + 2);
        iconText->SetFont(iconFont);
        sizer->Add(iconText, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 8);
 
        // Extract folder name from path
        wxFileName fn(item.path);
        wxString folderName = fn.GetDirs().IsEmpty() ? item.path : fn.GetDirs().Last();
 
        wxStaticText *text = new wxStaticText(panel, wxID_ANY, folderName);
        text->SetForegroundColour(isCurrent ? wxColour(255, 255, 255) : wxColour(200, 200, 200));
        wxFont textFont = text->GetFont();
        textFont.SetPointSize(textFont.GetPointSize() + 1);
        if (isCurrent) {
            textFont.SetWeight(wxFONTWEIGHT_BOLD);
        }
        text->SetFont(textFont);
        sizer->Add(text, 1, wxALIGN_CENTER_VERTICAL | wxALL, 10);
 
        panel->SetSizer(sizer);
        panel->SetToolTip(item.path);
 
        // Bind hover and click events
        panel->Bind(wxEVT_ENTER_WINDOW, [this, panel, index, isCurrent](wxMouseEvent &) {
            if (!isCurrent) {
                panel->SetBackgroundColour(wxColour(60, 80, 110));
                panel->Refresh();
                m_hoveredIndex = index;
            }
        });
 
        panel->Bind(wxEVT_LEAVE_WINDOW, [this, panel, isCurrent](wxMouseEvent &) {
            if (!isCurrent) {
                panel->SetBackgroundColour(wxColour(45, 45, 45));
                panel->Refresh();
                m_hoveredIndex = std::numeric_limits<size_t>::max();
            }
        });
 
        panel->Bind(wxEVT_LEFT_DOWN, [this, index](wxMouseEvent &) {
            if (m_onNavigate && index < m_items.size()) {
                m_onNavigate(m_items[index].path);
                Dismiss();
            }
        });
 
        // Also bind to child controls for proper event handling
        iconText->Bind(wxEVT_LEFT_DOWN, [this, index](wxMouseEvent &) {
            if (m_onNavigate && index < m_items.size()) {
                m_onNavigate(m_items[index].path);
                Dismiss();
            }
        });
 
        text->Bind(wxEVT_LEFT_DOWN, [this, index](wxMouseEvent &) {
            if (m_onNavigate && index < m_items.size()) {
                m_onNavigate(m_items[index].path);
                Dismiss();
            }
        });
 
        return panel;
    }
 
    std::function<void(const wxString &)> m_onNavigate;
    std::vector<HistoryItem> m_items;
    size_t m_hoveredIndex;
};
 
FileExplorerTab::FileExplorerTab(wxWindow *parent)
    : m_panel(nullptr), m_treeSearchCtrl(nullptr), m_gridSearchCtrl(nullptr), m_treeCtrl(nullptr), m_splitter(nullptr),
      m_leftPanel(nullptr), m_rightPanel(nullptr), m_gridCtrl(nullptr), m_gridSizer(nullptr), m_historyPanel(nullptr),
      m_breadcrumbContainerPanel(nullptr), m_navigationPanel(nullptr), m_breadcrumbPanel(nullptr),
      m_functionalPanel(nullptr), m_breadcrumbSizer(nullptr), m_contentSizer(nullptr), m_treeToggleBtn(nullptr),
      m_gridToggleBtn(nullptr), m_xmlFilterBtn(nullptr), m_pngFilterBtn(nullptr), m_jsonFilterBtn(nullptr),
      m_gridBackButton(nullptr), m_gridForwardButton(nullptr), m_historyButton(nullptr), m_activeFilter(""),
      m_isInitialized(false), m_syncInProgress(false), m_treeVisible(true), m_gridVisible(true),
      m_isNavigatingHistory(false), m_isHistoryVisible(false), m_activityHistory(), m_imageList(nullptr),
      m_folderIcon(0), m_fileIcon(0), m_selectedGridItem(nullptr), m_isDragging(false), m_dragStartPos(0, 0),
      m_dragWindow(nullptr), m_contextMenuPath(""), m_clipboardPath(""), m_clipboardIsCut(false),
      m_showBreadcrumb(true), m_showHistory(true), m_treeShowHiddenFiles(false), m_treeShowFileExtensions(true),
      m_treeSortFilesBy(static_cast<int>(EmberForge::AppPreferences::SortBy::Name)),
      m_treeItemSize(24) // Default to Medium
      ,
      m_gridShowHiddenFiles(false), m_gridShowFileExtensions(true),
      m_gridSortFilesBy(static_cast<int>(EmberForge::AppPreferences::SortBy::Name)),
      m_gridIconSize(80) // Default to Medium
{
    // Load settings from preferences
    LoadSettings();
    // Create the main panel
    m_panel = new wxPanel(parent, wxID_ANY);
    m_panel->SetBackgroundColour(wxColour(45, 45, 45));
 
    // Bind keyboard events for navigation shortcuts
    m_panel->Bind(wxEVT_CHAR_HOOK, &FileExplorerTab::OnNavigationKeyDown, this);
 
    // Bind click event to detect clicks outside history panel
    m_panel->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent &event) {
        if (m_isHistoryVisible && m_historyPanel) {
            // Check if click is outside history panel
            wxPoint clickPos = event.GetPosition();
            wxPoint panelPos = m_historyPanel->GetPosition();
            wxSize panelSize = m_historyPanel->GetSize();
            wxRect historyRect(panelPos, panelSize);
 
            if (!historyRect.Contains(clickPos)) {
                ToggleHistoryView();
            }
        }
        event.Skip(); // Allow the event to propagate
    });
 
    // Determine start path based on preferences
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &bottomSettings = prefs.GetBottomPanelSettings();
 
    switch (bottomSettings.startPathMode) {
    case EmberForge::AppPreferences::StartPathMode::ExecutableDirectory:
        m_rootPath = GetExecutableDirectory();
        LOG_INFO("FileExplorer", "Using executable directory as start path");
        break;
 
    case EmberForge::AppPreferences::StartPathMode::CustomPath:
        if (!bottomSettings.customStartPath.empty() && wxDir::Exists(wxString(bottomSettings.customStartPath))) {
            m_rootPath = wxString(bottomSettings.customStartPath);
            LOG_INFO("FileExplorer", "Using custom start path: " + m_rootPath.ToStdString());
        } else {
            m_rootPath = GetExecutableDirectory();
            LOG_WARNING("FileExplorer", "Custom path not found, using executable directory");
        }
        break;
 
    default:
        m_rootPath = GetExecutableDirectory();
        break;
    }
 
    m_currentGridPath = m_rootPath; // Start at root
 
    LOG_INFO("FileExplorer", "File explorer tab created with root: " + m_rootPath.ToStdString());
}
 
FileExplorerTab::~FileExplorerTab() {
    // Clean up breadcrumb button client data
    if (m_breadcrumbSizer) {
        for (size_t i = 0; i < m_breadcrumbSizer->GetItemCount(); i++) {
            wxSizerItem *item = m_breadcrumbSizer->GetItem(i);
            if (item && item->IsWindow()) {
                wxButton *btn = dynamic_cast<wxButton *>(item->GetWindow());
                if (btn && btn->GetClientData()) {
                    wxString *pathPtr = static_cast<wxString *>(btn->GetClientData());
                    delete pathPtr;
                    btn->SetClientData(nullptr);
                }
            }
        }
    }
 
    if (m_imageList) {
        delete m_imageList;
    }
    LOG_INFO("FileExplorer", "File explorer tab destroyed");
}
 
wxString FileExplorerTab::GetExecutableDirectory() const {
    // Return the resources directory path using centralized ResourcePath
    wxString resourcesDir = EmberForge::ResourcePath::GetResourcesDir();
    // Remove trailing separator if present (for consistency with original behavior)
    if (resourcesDir.EndsWith(wxFileName::GetPathSeparator())) {
        resourcesDir.RemoveLast();
    }
    return resourcesDir;
}
 
void FileExplorerTab::LoadSettings() {
    auto &prefs = EmberForge::AppPreferencesManager::GetInstance().GetPreferences();
    const auto &bottomSettings = prefs.GetBottomPanelSettings();
 
    m_showBreadcrumb = bottomSettings.showBreadcrumb;
    m_showHistory = bottomSettings.showHistory;
 
    // Load tree view settings
    m_treeShowHiddenFiles = bottomSettings.treeView.showHiddenFiles;
    m_treeShowFileExtensions = bottomSettings.treeView.showFileExtensions;
    m_treeSortFilesBy = static_cast<int>(bottomSettings.treeView.sortFilesBy);
    m_treeItemSize = static_cast<int>(bottomSettings.treeView.itemSize);
 
    // Load grid view settings
    m_gridShowHiddenFiles = bottomSettings.gridView.showHiddenFiles;
    m_gridShowFileExtensions = bottomSettings.gridView.showFileExtensions;
    m_gridSortFilesBy = static_cast<int>(bottomSettings.gridView.sortFilesBy);
    m_gridIconSize = static_cast<int>(bottomSettings.gridView.iconSize);
 
    LOG_INFO("FileExplorer",
             "Settings loaded - showBreadcrumb: " + std::to_string(m_showBreadcrumb) +
                 ", tree(hidden:" + std::to_string(m_treeShowHiddenFiles) +
                 " ext:" + std::to_string(m_treeShowFileExtensions) + " sort:" + std::to_string(m_treeSortFilesBy) +
                 ")" + ", grid(hidden:" + std::to_string(m_gridShowHiddenFiles) + " ext:" +
                 std::to_string(m_gridShowFileExtensions) + " sort:" + std::to_string(m_gridSortFilesBy) + ")");
}
 
wxString FileExplorerTab::GetDisplayName(const wxString &filename, bool isDirectory, bool isTreeView) const {
    // Directories always show full name
    if (isDirectory) {
        return filename;
    }
 
    // Files: show with or without extension based on view-specific preference
    bool showExtensions = isTreeView ? m_treeShowFileExtensions : m_gridShowFileExtensions;
    if (showExtensions) {
        return filename;
    }
 
    // Remove extension
    wxFileName fn(filename);
    return fn.GetName(); // Returns filename without extension
}
 
void FileExplorerTab::Initialize() {
    if (m_isInitialized) {
        return;
    }
 
    CreateLayout();
    PopulateTree();
    PopulateGrid(m_currentGridPath);
    UpdateBreadcrumb();
 
    // Initialize toggle button states to match actual visibility
    UpdateToggleButtonAppearance();
 
    // Sync toolbar search bar width with initial splitter position
    SyncToolbarWithSplitter();
 
    // Apply breadcrumb and history visibility from settings
    UpdateBreadcrumbVisibility();
    UpdateHistoryVisibility();
 
    m_isInitialized = true;
 
    LOG_INFO("FileExplorer", "File explorer tab initialized");
}
 
void FileExplorerTab::CreateLayout() {
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Create favorites bar at the top
    CreateFavoritesBar(mainSizer);
 
    // Create the split layout (tree + grid)
    CreateSplitLayout(mainSizer);
 
    m_panel->SetSizer(mainSizer);
    m_panel->Layout();
}
 
void FileExplorerTab::CreateFavoritesBar(wxBoxSizer *parentSizer) {
    // Create favorites panel
    wxPanel *favPanel = new wxPanel(m_panel, wxID_ANY);
    favPanel->SetBackgroundColour(wxColour(35, 35, 35));
 
    wxBoxSizer *favSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Add tree search control - width will be synced with splitter
    m_treeSearchCtrl = new wxSearchCtrl(favPanel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(200, -1));
    m_treeSearchCtrl->SetDescriptiveText("Search tree...");
    m_treeSearchCtrl->ShowCancelButton(true);
    m_treeSearchCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_treeSearchCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_treeSearchCtrl->Bind(wxEVT_TEXT, &FileExplorerTab::OnTreeSearchTextChanged, this);
    m_treeSearchCtrl->Bind(wxEVT_SEARCHCTRL_CANCEL_BTN, &FileExplorerTab::OnTreeSearchCancel, this);
    favSizer->Add(m_treeSearchCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 2);
 
    // Add vertical separator - this will visually align with the splitter
    wxStaticLine *separator = new wxStaticLine(favPanel, wxID_ANY, wxDefaultPosition, wxSize(2, 25), wxLI_VERTICAL);
    separator->SetBackgroundColour(wxColour(100, 100, 100));
    favSizer->Add(separator, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 5);
 
    // Add label
    wxStaticText *favLabel = new wxStaticText(favPanel, wxID_ANY, "Favorites:");
    favLabel->SetForegroundColour(wxColour(200, 200, 200));
    favSizer->Add(favLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    // Create toggle buttons for file type filters
    m_xmlFilterBtn = new wxToggleButton(favPanel, wxID_ANY, "All XML");
    m_xmlFilterBtn->SetBackgroundColour(wxColour(55, 55, 55));
    m_xmlFilterBtn->SetForegroundColour(wxColour(200, 200, 200));
    m_xmlFilterBtn->Bind(wxEVT_TOGGLEBUTTON, &FileExplorerTab::OnFavoriteFilter, this);
    favSizer->Add(m_xmlFilterBtn, 0, wxALL, 2);
 
    m_pngFilterBtn = new wxToggleButton(favPanel, wxID_ANY, "All PNG");
    m_pngFilterBtn->SetBackgroundColour(wxColour(55, 55, 55));
    m_pngFilterBtn->SetForegroundColour(wxColour(200, 200, 200));
    m_pngFilterBtn->Bind(wxEVT_TOGGLEBUTTON, &FileExplorerTab::OnFavoriteFilter, this);
    favSizer->Add(m_pngFilterBtn, 0, wxALL, 2);
 
    m_jsonFilterBtn = new wxToggleButton(favPanel, wxID_ANY, "All JSON");
    m_jsonFilterBtn->SetBackgroundColour(wxColour(55, 55, 55));
    m_jsonFilterBtn->SetForegroundColour(wxColour(200, 200, 200));
    m_jsonFilterBtn->Bind(wxEVT_TOGGLEBUTTON, &FileExplorerTab::OnFavoriteFilter, this);
    favSizer->Add(m_jsonFilterBtn, 0, wxALL, 2);
 
    favSizer->AddStretchSpacer(1);
 
    // Add vertical separator before view toggles
    wxStaticLine *viewSeparator = new wxStaticLine(favPanel, wxID_ANY, wxDefaultPosition, wxSize(2, 25), wxLI_VERTICAL);
    viewSeparator->SetBackgroundColour(wxColour(100, 100, 100));
    favSizer->Add(viewSeparator, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 5);
 
    // Add label for view toggles
    wxStaticText *viewLabel = new wxStaticText(favPanel, wxID_ANY, "View:");
    viewLabel->SetForegroundColour(wxColour(200, 200, 200));
    favSizer->Add(viewLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
 
    // Create toggle buttons for tree/grid visibility
    m_treeToggleBtn = new wxToggleButton(favPanel, wxID_ANY, "Tree");
    m_treeToggleBtn->SetValue(true); // Tree visible by default
    m_treeToggleBtn->SetBackgroundColour(wxColour(55, 55, 55));
    m_treeToggleBtn->SetForegroundColour(wxColour(200, 200, 200));
    m_treeToggleBtn->Bind(wxEVT_TOGGLEBUTTON, &FileExplorerTab::OnTreeToggle, this);
    favSizer->Add(m_treeToggleBtn, 0, wxALL, 2);
 
    m_gridToggleBtn = new wxToggleButton(favPanel, wxID_ANY, "Grid");
    m_gridToggleBtn->SetValue(true); // Grid visible by default
    m_gridToggleBtn->SetBackgroundColour(wxColour(55, 55, 55));
    m_gridToggleBtn->SetForegroundColour(wxColour(200, 200, 200));
    m_gridToggleBtn->Bind(wxEVT_TOGGLEBUTTON, &FileExplorerTab::OnGridToggle, this);
    favSizer->Add(m_gridToggleBtn, 0, wxALL, 2);
 
    favPanel->SetSizer(favSizer);
    parentSizer->Add(favPanel, 0, wxEXPAND | wxALL, 2);
}
 
void FileExplorerTab::CreateSplitLayout(wxBoxSizer *parentSizer) {
    // Create splitter window
    m_splitter = new wxSplitterWindow(m_panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_3D | wxSP_LIVE_UPDATE);
    m_splitter->SetMinimumPaneSize(150);
    m_splitter->SetSashGravity(0.15); // 15% for tree, 85% for grid
 
    // Bind splitter events to sync toolbar with splitter position
    m_splitter->Bind(wxEVT_SPLITTER_SASH_POS_CHANGED, &FileExplorerTab::OnSplitterSashPosChanged, this);
    m_splitter->Bind(wxEVT_SPLITTER_SASH_POS_CHANGING, &FileExplorerTab::OnSplitterSashPosChanging, this);
 
    // Create left panel for tree
    m_leftPanel = new wxPanel(m_splitter, wxID_ANY);
    m_leftPanel->SetBackgroundColour(wxColour(45, 45, 45));
    wxBoxSizer *leftSizer = new wxBoxSizer(wxVERTICAL);
 
    // Create image list for tree icons (size based on preference)
    m_imageList = new wxImageList(m_treeItemSize, m_treeItemSize);
    wxIcon folderIcon = LoadTreeIcon("folder");
    wxIcon fileIcon = LoadTreeIcon("file");
    if (folderIcon.IsOk()) {
        m_folderIcon = m_imageList->Add(folderIcon);
    }
    if (fileIcon.IsOk()) {
        m_fileIcon = m_imageList->Add(fileIcon);
    }
 
    // Create tree control
    m_treeCtrl =
        new wxTreeCtrl(m_leftPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTR_DEFAULT_STYLE | wxTR_HIDE_ROOT);
    m_treeCtrl->SetBackgroundColour(wxColour(45, 45, 45));
    m_treeCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_treeCtrl->AssignImageList(m_imageList);
    m_imageList = nullptr; // Tree now owns it
 
    // Set tree item spacing based on size preference
    // Spacing = itemSize + padding (4 pixels for small, 6 for medium, 8 for large)
    int spacing = m_treeItemSize + (m_treeItemSize == 16 ? 4 : (m_treeItemSize == 24 ? 6 : 8));
    m_treeCtrl->SetSpacing(spacing);
 
    // Bind tree events
    m_treeCtrl->Bind(wxEVT_TREE_SEL_CHANGED, &FileExplorerTab::OnSelectionChanged, this);
    m_treeCtrl->Bind(wxEVT_TREE_ITEM_ACTIVATED, &FileExplorerTab::OnItemActivated, this);
    m_treeCtrl->Bind(wxEVT_TREE_ITEM_EXPANDING, &FileExplorerTab::OnItemExpanding, this);
    m_treeCtrl->Bind(wxEVT_TREE_BEGIN_DRAG, &FileExplorerTab::OnBeginDrag, this);
    m_treeCtrl->Bind(wxEVT_TREE_ITEM_MENU, &FileExplorerTab::OnTreeContextMenu, this);
 
    // Close history panel when clicking on tree
    m_treeCtrl->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent &event) {
        if (m_isHistoryVisible) {
            ToggleHistoryView();
        }
        event.Skip();
    });
 
    leftSizer->Add(m_treeCtrl, 1, wxEXPAND | wxALL, 2);
    m_leftPanel->SetSizer(leftSizer);
 
    // Create right panel for grid
    m_rightPanel = new wxPanel(m_splitter, wxID_ANY);
    m_rightPanel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *rightSizer = new wxBoxSizer(wxVERTICAL);
 
    // Create breadcrumb and grid
    CreateBreadcrumb(m_rightPanel, rightSizer);
 
    // Store the content sizer for toggling between grid and history
    m_contentSizer = rightSizer;
 
    CreateIconGrid(m_rightPanel, rightSizer);
    CreateHistoryPanel(m_rightPanel, rightSizer);
 
    m_rightPanel->SetSizer(rightSizer);
 
    // Split the window with initial position at 200 pixels (15% for tree, 85% for grid)
    m_splitter->SplitVertically(m_leftPanel, m_rightPanel, 200);
 
    parentSizer->Add(m_splitter, 1, wxEXPAND | wxALL, 0);
}
 
void FileExplorerTab::CreateBreadcrumb(wxPanel *rightPanel, wxBoxSizer *rightSizer) {
    // Create container panel that holds navigation, breadcrumb, and functional panels
    m_breadcrumbContainerPanel = new wxPanel(rightPanel, wxID_ANY);
    m_breadcrumbContainerPanel->SetBackgroundColour(wxColour(40, 40, 40));
    m_breadcrumbContainerPanel->SetMinSize(wxSize(-1, 50)); // Taller container for bigger buttons
    wxBoxSizer *containerSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // ===== LEFT SIDE: Navigation Panel (Back/Forward buttons + Grid Search) =====
    m_navigationPanel = new wxPanel(m_breadcrumbContainerPanel, wxID_ANY);
    m_navigationPanel->SetBackgroundColour(wxColour(40, 40, 40));
    wxBoxSizer *navSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Load back button bitmaps
    wxString leftArrowPath = m_rootPath + wxFileName::GetPathSeparator() + "buttons" + wxFileName::GetPathSeparator() +
                             "left_arrow" + wxFileName::GetPathSeparator();
    wxBitmap gridBackNormal(leftArrowPath + "LeftArrow_Normal_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap gridBackHovered(leftArrowPath + "LeftArrow_Hovered_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap gridBackPressed(leftArrowPath + "LeftArrow_Pressed_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap gridBackDisabled(leftArrowPath + "LeftArrow_Disabled_20.png", wxBITMAP_TYPE_PNG);
 
    m_gridBackButton =
        new wxBitmapButton(m_navigationPanel, wxID_ANY, gridBackNormal, wxDefaultPosition, wxSize(36, 36));
    m_gridBackButton->SetBitmapHover(gridBackHovered);
    m_gridBackButton->SetBitmapPressed(gridBackPressed);
    m_gridBackButton->SetBitmapDisabled(gridBackDisabled);
    m_gridBackButton->SetBackgroundColour(wxColour(40, 40, 40));
    m_gridBackButton->SetToolTip("Go Back (Alt+Left)");
    m_gridBackButton->Enable(false); // Disabled initially (no history)
    m_gridBackButton->Bind(wxEVT_BUTTON, &FileExplorerTab::OnBackButton, this);
    navSizer->Add(m_gridBackButton, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 4);
 
    // Load forward button bitmaps
    wxString rightArrowPath = m_rootPath + wxFileName::GetPathSeparator() + "buttons" + wxFileName::GetPathSeparator() +
                              "right_arrow" + wxFileName::GetPathSeparator();
    wxBitmap gridForwardNormal(rightArrowPath + "RightArrow_Normal_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap gridForwardHovered(rightArrowPath + "RightArrow_Hovered_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap gridForwardPressed(rightArrowPath + "RightArrow_Pressed_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap gridForwardDisabled(rightArrowPath + "RightArrow_Disabled_20.png", wxBITMAP_TYPE_PNG);
 
    m_gridForwardButton =
        new wxBitmapButton(m_navigationPanel, wxID_ANY, gridForwardNormal, wxDefaultPosition, wxSize(36, 36));
    m_gridForwardButton->SetBitmapHover(gridForwardHovered);
    m_gridForwardButton->SetBitmapPressed(gridForwardPressed);
    m_gridForwardButton->SetBitmapDisabled(gridForwardDisabled);
    m_gridForwardButton->SetBackgroundColour(wxColour(40, 40, 40));
    m_gridForwardButton->SetToolTip("Go Forward (Alt+Right)");
    m_gridForwardButton->Enable(false); // Disabled initially (no forward history)
    m_gridForwardButton->Bind(wxEVT_BUTTON, &FileExplorerTab::OnForwardButton, this);
    navSizer->Add(m_gridForwardButton, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
    // Add grid search control
    m_gridSearchCtrl = new wxSearchCtrl(m_navigationPanel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(200, -1));
    m_gridSearchCtrl->SetDescriptiveText("Search grid...");
    m_gridSearchCtrl->ShowCancelButton(true);
    m_gridSearchCtrl->SetBackgroundColour(wxColour(60, 60, 60));
    m_gridSearchCtrl->SetForegroundColour(wxColour(200, 200, 200));
    m_gridSearchCtrl->Bind(wxEVT_TEXT, &FileExplorerTab::OnGridSearchTextChanged, this);
    m_gridSearchCtrl->Bind(wxEVT_SEARCHCTRL_CANCEL_BTN, &FileExplorerTab::OnGridSearchCancel, this);
    navSizer->Add(m_gridSearchCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 2);
 
    m_navigationPanel->SetSizer(navSizer);
    containerSizer->Add(m_navigationPanel, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxTOP | wxBOTTOM, 5);
 
    // ===== CENTER: Breadcrumb Panel (Path buttons) =====
    m_breadcrumbPanel = new wxPanel(m_breadcrumbContainerPanel, wxID_ANY);
    m_breadcrumbPanel->SetBackgroundColour(wxColour(40, 40, 40));
 
    m_breadcrumbSizer = new wxBoxSizer(wxHORIZONTAL);
    // Breadcrumb path items will be added here dynamically by UpdateBreadcrumb()
 
    m_breadcrumbPanel->SetSizer(m_breadcrumbSizer);
    containerSizer->Add(m_breadcrumbPanel, 1, wxEXPAND | wxTOP | wxBOTTOM, 5);
 
    // ===== RIGHT SIDE: Functional Panel (History and other functional buttons) =====
    m_functionalPanel = new wxPanel(m_breadcrumbContainerPanel, wxID_ANY);
    m_functionalPanel->SetBackgroundColour(wxColour(40, 40, 40));
    wxBoxSizer *functionalSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Load history button bitmaps
    wxString historyPath = m_rootPath + wxFileName::GetPathSeparator() + "buttons" + wxFileName::GetPathSeparator() +
                           "history" + wxFileName::GetPathSeparator();
    wxBitmap historyNormal(historyPath + "History_Normal_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap historyHovered(historyPath + "History_Hovered_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap historyPressed(historyPath + "History_Pressed_20.png", wxBITMAP_TYPE_PNG);
    wxBitmap historyDisabled(historyPath + "History_Disabled_20.png", wxBITMAP_TYPE_PNG);
 
    m_historyButton = new wxBitmapButton(m_functionalPanel, wxID_ANY, historyNormal, wxDefaultPosition, wxSize(36, 36));
    m_historyButton->SetBitmapHover(historyHovered);
    m_historyButton->SetBitmapPressed(historyPressed);
    m_historyButton->SetBitmapDisabled(historyDisabled);
    m_historyButton->SetBackgroundColour(wxColour(40, 40, 40));
    m_historyButton->SetToolTip("Show Navigation History");
    m_historyButton->Bind(wxEVT_BUTTON, &FileExplorerTab::OnHistoryButton, this);
    functionalSizer->Add(m_historyButton, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 10);
 
    m_functionalPanel->SetSizer(functionalSizer);
    containerSizer->Add(m_functionalPanel, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT | wxTOP | wxBOTTOM, 5);
 
    // Set container sizer and add to parent
    m_breadcrumbContainerPanel->SetSizer(containerSizer);
    rightSizer->Add(m_breadcrumbContainerPanel, 0, wxEXPAND | wxALL, 2);
}
 
void FileExplorerTab::CreateIconGrid(wxPanel *rightPanel, wxBoxSizer *rightSizer) {
    // Create scrolled window for the icon grid
    m_gridCtrl = new wxScrolledWindow(rightPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL | wxHSCROLL);
    m_gridCtrl->SetBackgroundColour(wxColour(50, 50, 50));
    m_gridCtrl->SetScrollRate(10, 10);
 
    // Create wrap sizer for grid layout
    // wxEXTEND_LAST_ON_EACH_LINE: 0x0000 means items won't stretch to fill
    m_gridSizer = new wxWrapSizer(wxHORIZONTAL, 0);
    m_gridCtrl->SetSizer(m_gridSizer);
 
    // Bind right-click on empty space in grid
    m_gridCtrl->Bind(wxEVT_RIGHT_DOWN, &FileExplorerTab::OnGridBackgroundContextMenu, this);
 
    // Close history panel when clicking on grid
    m_gridCtrl->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent &event) {
        if (m_isHistoryVisible) {
            ToggleHistoryView();
        }
        event.Skip();
    });
 
    // Add to sizer - will be visible by default
    rightSizer->Add(m_gridCtrl, 1, wxEXPAND | wxALL, 2);
}
 
void FileExplorerTab::CreateHistoryPanel(wxPanel *rightPanel, wxBoxSizer *rightSizer) {
    // Create scrolled window for the history panel
    m_historyPanel = new wxScrolledWindow(rightPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL);
    m_historyPanel->SetBackgroundColour(wxColour(45, 45, 45));
    m_historyPanel->SetScrollRate(0, 10);
 
    // Add to sizer but hide initially
    rightSizer->Add(m_historyPanel, 1, wxEXPAND | wxALL, 2);
    m_historyPanel->Hide();
}
 
wxBitmap FileExplorerTab::LoadGridIcon(const wxString &iconType, const wxSize &size) {
    // Check cache first
    wxString cacheKey = iconType + wxString::Format("_%dx%d", size.GetWidth(), size.GetHeight());
    auto it = m_gridIcons.find(cacheKey);
    if (it != m_gridIcons.end()) {
        return it->second;
    }
 
    // Try to load custom icons for specific file types
    if (iconType == "xml" || iconType == "json" || iconType == "txt" || iconType == "png" || iconType == "markdown") {
        wxString iconPath = m_rootPath + wxFileName::GetPathSeparator() + "icons" + wxFileName::GetPathSeparator() +
                            iconType + "_file" + wxFileName::GetPathSeparator() + iconType + "_file_128px.png";
 
        if (wxFileExists(iconPath)) {
            wxBitmap customIcon;
            customIcon.LoadFile(iconPath, wxBITMAP_TYPE_PNG);
            if (customIcon.IsOk()) {
                wxImage img = customIcon.ConvertToImage();
                img.Rescale(size.GetWidth(), size.GetHeight(), wxIMAGE_QUALITY_HIGH);
                wxBitmap scaled(img);
                m_gridIcons[cacheKey] = scaled;
                LOG_INFO("FileExplorer",
                         "Loaded custom " + iconType.Upper().ToStdString() + " icon: " + iconPath.ToStdString());
                return scaled;
            }
        } else {
            LOG_WARNING("FileExplorer",
                        "Custom " + iconType.Upper().ToStdString() + " icon not found: " + iconPath.ToStdString());
        }
    }
 
    // Fall back to wxArtProvider
    wxArtID artId = wxART_NORMAL_FILE;
    if (iconType == "folder") {
        artId = wxART_FOLDER;
    } else if (iconType == "file" || iconType == "xml" || iconType == "json" || iconType == "txt" ||
               iconType == "png" || iconType == "markdown") {
        artId = wxART_NORMAL_FILE;
    }
 
    wxBitmap bitmap = wxArtProvider::GetBitmap(artId, wxART_OTHER, size);
    m_gridIcons[cacheKey] = bitmap;
    return bitmap;
}
 
wxIcon FileExplorerTab::LoadTreeIcon(const wxString &iconType) {
    // Try to load custom icon (commented out for now)
    // wxString iconPath = m_rootPath + "/icons/" + iconType + "_small.png";
    // if (wxFileExists(iconPath)) {
    //     wxIcon icon;
    //     icon.LoadFile(iconPath, wxBITMAP_TYPE_PNG, m_treeItemSize, m_treeItemSize);
    //     if (icon.IsOk()) return icon;
    // }
 
    // Fall back to wxArtProvider (use dynamic size based on preference)
    wxArtID artId = wxART_NORMAL_FILE;
    if (iconType == "folder") {
        artId = wxART_FOLDER;
    } else if (iconType == "file") {
        artId = wxART_NORMAL_FILE;
    }
 
    return wxArtProvider::GetIcon(artId, wxART_OTHER, wxSize(m_treeItemSize, m_treeItemSize));
}
 
void FileExplorerTab::PopulateTree() {
    if (!m_treeCtrl) {
        LOG_ERROR("FileExplorer", "Tree control is null, cannot populate");
        return;
    }
 
    LOG_INFO("FileExplorer", wxString::Format("Populating tree with root: %s", m_rootPath).ToStdString());
 
    m_treeCtrl->DeleteAllItems();
 
    // Create root with the actual path name
    wxFileName fn(m_rootPath);
    wxString rootName = fn.GetFullName().IsEmpty() ? m_rootPath : fn.GetFullName();
    wxTreeItemId root = m_treeCtrl->AddRoot(rootName);
 
    // Add the resources directory contents
    AddDirectoryToTree(m_rootPath, root);
 
    // Don't expand root when using wxTR_HIDE_ROOT flag - it causes assertion
    // The root children are already visible since root is hidden
 
    LOG_INFO("FileExplorer", "Tree population completed");
}
 
void FileExplorerTab::AddDirectoryToTree(const wxString &path, wxTreeItemId parentItem) {
    LOG_INFO("FileExplorer", wxString::Format("Adding directory to tree: %s", path).ToStdString());
 
    if (!wxDir::Exists(path)) {
        LOG_ERROR("FileExplorer", wxString::Format("Directory does not exist: %s", path).ToStdString());
        return;
    }
 
    wxDir dir(path);
    if (!dir.IsOpened()) {
        LOG_ERROR("FileExplorer", wxString::Format("Cannot open directory: %s", path).ToStdString());
        return;
    }
 
    // Collect directories and files for sorting
    struct FileInfo {
        wxString name;
        wxString fullPath;
        bool isDirectory;
        wxDateTime modTime;
        wxULongLong size;
    };
    std::vector<FileInfo> directories;
    std::vector<FileInfo> files;
 
    // First, collect all subdirectories
    wxString filename;
    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
    while (cont) {
        // Skip hidden directories based on preference
        bool isHidden = filename.StartsWith(".");
        if (m_treeShowHiddenFiles || !isHidden) {
            wxString fullPath = path + wxFileName::GetPathSeparator() + filename;
 
            // When filter is active, only show directories that contain matching files
            if (DirectoryContainsMatchingFiles(fullPath)) {
                FileInfo info;
                info.name = filename;
                info.fullPath = fullPath;
                info.isDirectory = true;
 
                // Get file info for sorting
                wxFileName fn(fullPath);
                fn.GetTimes(nullptr, &info.modTime, nullptr);
                info.size = 0; // Directories don't have a simple size
 
                directories.push_back(info);
            }
        }
        cont = dir.GetNext(&filename);
    }
 
    // Then, collect all files (with filter applied)
    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES);
    while (cont) {
        // Skip hidden files based on preference, and apply favorites filter
        bool isHidden = filename.StartsWith(".");
        if ((m_treeShowHiddenFiles || !isHidden) && PassesFilter(filename)) {
            wxString fullPath = path + wxFileName::GetPathSeparator() + filename;
 
            FileInfo info;
            info.name = filename;
            info.fullPath = fullPath;
            info.isDirectory = false;
 
            // Get file info for sorting
            wxFileName fn(fullPath);
            fn.GetTimes(nullptr, &info.modTime, nullptr);
            info.size = fn.GetSize();
 
            files.push_back(info);
        }
        cont = dir.GetNext(&filename);
    }
 
    // Sort based on preference
    auto sortFunc = [this](const FileInfo &a, const FileInfo &b) -> bool {
        EmberForge::AppPreferences::SortBy sortBy = static_cast<EmberForge::AppPreferences::SortBy>(m_treeSortFilesBy);
        switch (sortBy) {
        case EmberForge::AppPreferences::SortBy::Name:
            return a.name.CmpNoCase(b.name) < 0;
        case EmberForge::AppPreferences::SortBy::Date:
            return a.modTime > b.modTime; // Most recent first
        case EmberForge::AppPreferences::SortBy::Size:
            return a.size > b.size; // Largest first
        case EmberForge::AppPreferences::SortBy::Type: {
            wxString extA = wxFileName(a.name).GetExt().Lower();
            wxString extB = wxFileName(b.name).GetExt().Lower();
            if (extA != extB)
                return extA < extB;
            return a.name.CmpNoCase(b.name) < 0;
        }
        }
        return a.name.CmpNoCase(b.name) < 0; // Default fallback
    };
 
    std::sort(directories.begin(), directories.end(), sortFunc);
    std::sort(files.begin(), files.end(), sortFunc);
 
    // Add sorted directories to tree
    for (const auto &dirInfo : directories) {
        wxString displayName = GetDisplayName(dirInfo.name, true, true);
        wxTreeItemId item = m_treeCtrl->AppendItem(parentItem, displayName, m_folderIcon, m_folderIcon,
                                                   new FileTreeItemData(dirInfo.fullPath, true));
 
        // Recursively populate subdirectory immediately (no lazy loading)
        AddDirectoryToTree(dirInfo.fullPath, item);
    }
 
    // Add sorted files to tree
    for (const auto &fileInfo : files) {
        wxString displayName = GetDisplayName(fileInfo.name, false, true);
        m_treeCtrl->AppendItem(parentItem, displayName, m_fileIcon, m_fileIcon,
                               new FileTreeItemData(fileInfo.fullPath, false));
    }
}
 
void FileExplorerTab::OnItemExpanding(wxTreeEvent &event) {
    wxTreeItemId item = event.GetItem();
    if (!item.IsOk()) {
        return;
    }
 
    // Check if we've already populated this item
    wxTreeItemIdValue cookie;
    wxTreeItemId child = m_treeCtrl->GetFirstChild(item, cookie);
    if (child.IsOk()) {
        wxString text = m_treeCtrl->GetItemText(child);
        if (text == "Loading...") {
            // Remove the dummy item
            m_treeCtrl->Delete(child);
 
            // Get the path for this item
            FileTreeItemData *data = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(item));
            if (data && data->IsDirectory()) {
                AddDirectoryToTree(data->GetPath(), item);
            }
        }
    }
}
 
wxWindow *FileExplorerTab::GetWidget() { return m_panel; }
 
wxString FileExplorerTab::GetTitle() const { return "File Explorer"; }
 
wxString FileExplorerTab::GetTabType() const { return "FileExplorer"; }
 
wxBitmap FileExplorerTab::GetIcon() const { return wxNullBitmap; }
 
void FileExplorerTab::Refresh() {
    // Reload settings in case they changed
    LoadSettings();
 
    // Update breadcrumb and history visibility based on settings
    UpdateBreadcrumbVisibility();
    UpdateHistoryVisibility();
 
    // Update tree image list if size changed
    UpdateTreeImageList();
 
    // Refresh both tree and grid
    PopulateTree();
    if (!m_currentGridPath.IsEmpty()) {
        PopulateGrid(m_currentGridPath);
    }
}
 
void FileExplorerTab::OnActivated() { LOG_INFO("FileExplorer", "File explorer tab activated"); }
 
void FileExplorerTab::OnDeactivated() { LOG_INFO("FileExplorer", "File explorer tab deactivated"); }
 
void FileExplorerTab::OnClosed() { LOG_INFO("FileExplorer", "File explorer tab closed"); }
 
bool FileExplorerTab::IsValid() const { return m_isInitialized && m_panel != nullptr && m_treeCtrl != nullptr; }
 
bool FileExplorerTab::CanClose() const { return true; }
 
bool FileExplorerTab::CanMove() const { return true; }
 
wxString FileExplorerTab::GetSelectedFile() const {
    if (m_treeCtrl) {
        wxTreeItemId sel = m_treeCtrl->GetSelection();
        if (sel.IsOk()) {
            FileTreeItemData *data = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(sel));
            if (data) {
                return data->GetPath();
            }
        }
    }
    return wxEmptyString;
}
 
void FileExplorerTab::SetRootDirectory(const wxString &path) {
    m_rootPath = path;
    if (m_isInitialized) {
        PopulateTree();
    }
}
 
void FileExplorerTab::OnSelectionChanged(wxTreeEvent &event) {
    // No automatic syncing - user must double-click to navigate
    // Just log the selection for debugging
    wxTreeItemId item = event.GetItem();
    if (item.IsOk()) {
        FileTreeItemData *data = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(item));
        if (data) {
            LOG_INFO("FileExplorer", "Tree selection changed: " + data->GetPath().ToStdString());
        }
    }
 
    event.Skip();
}
 
void FileExplorerTab::OnItemActivated(wxTreeEvent &event) {
    wxTreeItemId item = event.GetItem();
    if (!item.IsOk()) {
        event.Skip();
        return;
    }
 
    FileTreeItemData *data = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(item));
    if (!data) {
        event.Skip();
        return;
    }
 
    // Only sync and navigate when double-clicking folders
    if (data->IsDirectory()) {
        wxString path = data->GetPath();
        LOG_INFO("FileExplorer", "Tree folder activated (double-click): " + path.ToStdString());
        NavigateToPath(path);
    } else {
        // For files, just log (future: open file in editor)
        LOG_INFO("FileExplorer", "Tree file activated: " + data->GetPath().ToStdString());
    }
 
    event.Skip();
}
 
void FileExplorerTab::OnBeginDrag(wxTreeEvent &event) {
    wxTreeItemId item = event.GetItem();
    if (!item.IsOk()) {
        return;
    }
 
    // Get the item data
    FileTreeItemData *data = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(item));
    if (!data) {
        return;
    }
 
    // Only allow dragging files, not directories
    if (data->IsDirectory()) {
        LOG_INFO("FileExplorer", "Cannot drag directories");
        return;
    }
 
    wxString filePath = data->GetPath();
 
    // Only allow dragging XML files
    if (!filePath.Lower().EndsWith(".xml")) {
        LOG_INFO("FileExplorer", "Only XML files can be dragged");
        return;
    }
 
    LOG_INFO("FileExplorer", "Starting drag for file: " + filePath.ToStdString());
 
    // Create a file data object with the file path
    wxFileDataObject fileData;
    fileData.AddFile(filePath);
 
    // Create a drop source and begin the drag operation
    wxDropSource dragSource(fileData, m_treeCtrl);
    wxDragResult result = dragSource.DoDragDrop(wxDrag_DefaultMove);
 
    // Log the result
    switch (result) {
    case wxDragCopy:
        LOG_INFO("FileExplorer", "File copied");
        break;
    case wxDragMove:
        LOG_INFO("FileExplorer", "File moved");
        break;
    case wxDragCancel:
        LOG_INFO("FileExplorer", "Drag cancelled");
        break;
    default:
        LOG_INFO("FileExplorer", "Drag completed with unknown result");
        break;
    }
}
 
void FileExplorerTab::OnTreeSearchTextChanged(wxCommandEvent &event) {
    wxString searchText = m_treeSearchCtrl->GetValue();
    FilterTree(searchText);
}
 
void FileExplorerTab::OnTreeSearchCancel(wxCommandEvent &event) {
    m_treeSearchCtrl->SetValue(wxEmptyString);
    FilterTree(wxEmptyString);
}
 
void FileExplorerTab::OnGridSearchTextChanged(wxCommandEvent &event) {
    wxString searchText = m_gridSearchCtrl->GetValue();
    FilterGrid(searchText);
}
 
void FileExplorerTab::OnGridSearchCancel(wxCommandEvent &event) {
    m_gridSearchCtrl->SetValue(wxEmptyString);
    FilterGrid(wxEmptyString);
}
 
void FileExplorerTab::FilterTree(const wxString &searchText) {
    if (!m_treeCtrl) {
        return;
    }
 
    // Simply repopulate the tree - it will rebuild from scratch
    PopulateTree();
 
    if (searchText.IsEmpty()) {
        return;
    }
 
    wxTreeItemId root = m_treeCtrl->GetRootItem();
    if (!root.IsOk()) {
        return;
    }
 
    // Expand and highlight only matching items
    bool foundAny = false;
    ExpandAllMatching(root, searchText.Lower(), foundAny);
 
    if (foundAny) {
        LOG_INFO("FileExplorer", "Search found matches for: " + searchText.ToStdString());
    } else {
        LOG_INFO("FileExplorer", "No matches found for: " + searchText.ToStdString());
    }
}
 
void FileExplorerTab::ExpandAllMatching(wxTreeItemId item, const wxString &searchText, bool &foundAny) {
    if (!item.IsOk()) {
        return;
    }
 
    // Check if current item matches
    bool thisMatches = ItemMatchesSearch(item, searchText);
 
    // Process children first (so we can safely delete non-matching ones)
    wxTreeItemIdValue cookie;
    wxTreeItemId child = m_treeCtrl->GetFirstChild(item, cookie);
    bool anyChildMatches = false;
 
    std::vector<wxTreeItemId> childrenToDelete;
 
    while (child.IsOk()) {
        wxTreeItemId nextChild = m_treeCtrl->GetNextChild(item, cookie);
 
        bool childOrDescendantMatches = false;
        ExpandAllMatching(child, searchText, childOrDescendantMatches);
 
        if (childOrDescendantMatches) {
            anyChildMatches = true;
        } else {
            // Mark for deletion
            childrenToDelete.push_back(child);
        }
 
        child = nextChild;
    }
 
    // Delete non-matching children
    for (const auto &childToDelete : childrenToDelete) {
        m_treeCtrl->Delete(childToDelete);
    }
 
    // Determine if this item should be kept
    bool shouldKeep = thisMatches || anyChildMatches;
 
    if (shouldKeep) {
        // Expand this item to reveal matching children
        if (anyChildMatches || thisMatches) {
            // Don't expand root item when using wxTR_HIDE_ROOT
            if (item != m_treeCtrl->GetRootItem()) {
                m_treeCtrl->Expand(item);
            }
        }
 
        // Highlight directly matching items
        m_treeCtrl->SetItemBold(item, thisMatches);
        foundAny = true;
    }
}
 
bool FileExplorerTab::ItemMatchesSearch(wxTreeItemId item, const wxString &searchText) const {
    if (!item.IsOk() || searchText.IsEmpty()) {
        return false;
    }
 
    // Get item text and convert to lowercase for case-insensitive search
    wxString itemText = m_treeCtrl->GetItemText(item).Lower();
 
    // Check if the item text contains the search text
    return itemText.Contains(searchText);
}
 
bool FileExplorerTab::DirectoryContainsMatchingFiles(const wxString &dirPath) const {
    // If no filter is active, all directories are valid
    if (m_activeFilter.IsEmpty()) {
        return true;
    }
 
    if (!wxDir::Exists(dirPath)) {
        return false;
    }
 
    wxDir dir(dirPath);
    if (!dir.IsOpened()) {
        return false;
    }
 
    // Check files in this directory
    wxString filename;
    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES);
    while (cont) {
        if (!filename.StartsWith(".") && PassesFilter(filename)) {
            return true; // Found a matching file
        }
        cont = dir.GetNext(&filename);
    }
 
    // Recursively check subdirectories
    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
    while (cont) {
        if (!filename.StartsWith(".")) {
            wxString fullPath = dirPath + wxFileName::GetPathSeparator() + filename;
            if (DirectoryContainsMatchingFiles(fullPath)) {
                return true; // Found a matching file in subdirectory
            }
        }
        cont = dir.GetNext(&filename);
    }
 
    return false; // No matching files found
}
 
void FileExplorerTab::FilterGrid(const wxString &searchText) {
    if (!m_gridCtrl) {
        LOG_WARNING("FileExplorer", "Grid control not initialized");
        return;
    }
 
    if (m_gridItems.empty()) {
        LOG_WARNING("FileExplorer", "No grid items to filter");
        return;
    }
 
    wxString lowerSearchText = searchText.Lower();
    bool hasFilter = !searchText.IsEmpty();
 
    LOG_INFO("FileExplorer", "Filtering " + std::to_string(m_gridItems.size()) + " grid items with search: '" +
                                 searchText.ToStdString() + "'");
 
    int matchCount = 0;
    // Show/hide grid items based on search text
    for (auto &item : m_gridItems) {
        if (item.widget) {
            if (hasFilter) {
                // Check if item name contains the search text (case-insensitive)
                wxString lowerItemName = item.name.Lower();
                bool matches = lowerItemName.Contains(lowerSearchText);
 
                if (matches) {
                    LOG_INFO("FileExplorer",
                             "  MATCH: '" + item.name.ToStdString() + "' contains '" + searchText.ToStdString() + "'");
                    matchCount++;
                }
 
                item.widget->Show(matches);
            } else {
                // No filter - show all items
                item.widget->Show(true);
            }
        }
    }
 
    // Update layout to reflect visibility changes
    m_gridSizer->Layout();
    m_gridCtrl->FitInside();
    m_gridCtrl->Refresh();
 
    if (hasFilter) {
        LOG_INFO("FileExplorer", "Grid filter complete: " + std::to_string(matchCount) + " matches found for '" +
                                     searchText.ToStdString() + "'");
    } else {
        LOG_INFO("FileExplorer", "Grid filter cleared - showing all items");
    }
}
 
// ============================================================================
// Grid Population Methods
// ============================================================================
 
void FileExplorerTab::PopulateGrid(const wxString &path) {
    if (!m_gridCtrl || !m_gridSizer) {
        LOG_ERROR("FileExplorer", "Grid control not initialized");
        return;
    }
 
    ClearGrid();
    m_currentGridPath = path;
 
    LOG_INFO("FileExplorer", "Populating grid with path: " + path.ToStdString());
 
    if (!wxDir::Exists(path)) {
        LOG_ERROR("FileExplorer", "Path does not exist: " + path.ToStdString());
        return;
    }
 
    wxDir dir(path);
    if (!dir.IsOpened()) {
        LOG_ERROR("FileExplorer", "Cannot open directory: " + path.ToStdString());
        return;
    }
 
    // Collect directories and files for sorting
    struct FileInfo {
        wxString name;
        wxString fullPath;
        bool isDirectory;
        wxDateTime modTime;
        wxULongLong size;
    };
    std::vector<FileInfo> directories;
    std::vector<FileInfo> files;
 
    // First collect directories
    wxString filename;
    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
    while (cont) {
        bool isHidden = filename.StartsWith(".");
        if (m_gridShowHiddenFiles || !isHidden) {
            wxString fullPath = path + wxFileName::GetPathSeparator() + filename;
 
            FileInfo info;
            info.name = filename;
            info.fullPath = fullPath;
            info.isDirectory = true;
 
            wxFileName fn(fullPath);
            fn.GetTimes(nullptr, &info.modTime, nullptr);
            info.size = 0;
 
            directories.push_back(info);
        }
        cont = dir.GetNext(&filename);
    }
 
    // Then collect files
    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES);
    while (cont) {
        bool isHidden = filename.StartsWith(".");
        if (m_gridShowHiddenFiles || !isHidden) {
            wxString fullPath = path + wxFileName::GetPathSeparator() + filename;
 
            FileInfo info;
            info.name = filename;
            info.fullPath = fullPath;
            info.isDirectory = false;
 
            wxFileName fn(fullPath);
            fn.GetTimes(nullptr, &info.modTime, nullptr);
            info.size = fn.GetSize();
 
            files.push_back(info);
        }
        cont = dir.GetNext(&filename);
    }
 
    // Sort based on preference
    auto sortFunc = [this](const FileInfo &a, const FileInfo &b) -> bool {
        EmberForge::AppPreferences::SortBy sortBy = static_cast<EmberForge::AppPreferences::SortBy>(m_gridSortFilesBy);
        switch (sortBy) {
        case EmberForge::AppPreferences::SortBy::Name:
            return a.name.CmpNoCase(b.name) < 0;
        case EmberForge::AppPreferences::SortBy::Date:
            return a.modTime > b.modTime; // Most recent first
        case EmberForge::AppPreferences::SortBy::Size:
            return a.size > b.size; // Largest first
        case EmberForge::AppPreferences::SortBy::Type: {
            wxString extA = wxFileName(a.name).GetExt().Lower();
            wxString extB = wxFileName(b.name).GetExt().Lower();
            if (extA != extB)
                return extA < extB;
            return a.name.CmpNoCase(b.name) < 0;
        }
        }
        return a.name.CmpNoCase(b.name) < 0; // Default fallback
    };
 
    std::sort(directories.begin(), directories.end(), sortFunc);
    std::sort(files.begin(), files.end(), sortFunc);
 
    // Add sorted directories to grid
    for (const auto &dirInfo : directories) {
        wxString displayName = GetDisplayName(dirInfo.name, true, false);
        AddGridItem(displayName, dirInfo.fullPath, true);
    }
 
    // Add sorted files to grid
    for (const auto &fileInfo : files) {
        wxString displayName = GetDisplayName(fileInfo.name, false, false);
        AddGridItem(displayName, fileInfo.fullPath, false);
    }
 
    // Update layout properly
    m_gridSizer->Layout();
 
    // Set the virtual size to exactly fit the content (no extra space to distribute)
    wxSize minSize = m_gridSizer->GetMinSize();
    m_gridCtrl->SetVirtualSize(minSize);
 
    m_gridCtrl->Layout();
    m_gridCtrl->FitInside();
    m_gridCtrl->Refresh();
}
 
void FileExplorerTab::ClearGrid() {
    if (!m_gridSizer)
        return;
 
    // Clear selection
    m_selectedGridItem = nullptr;
 
    // Delete all grid item widgets and their client data
    for (auto &item : m_gridItems) {
        if (item.widget) {
            // First, delete the client data to avoid memory leak
            FileTreeItemData *data = static_cast<FileTreeItemData *>(item.widget->GetClientData());
            if (data) {
                delete data;
                item.widget->SetClientData(nullptr);
            }
            // Then destroy the widget
            item.widget->Destroy();
        }
    }
    m_gridItems.clear();
 
    m_gridSizer->Clear();
}
 
void FileExplorerTab::AddGridItem(const wxString &name, const wxString &fullPath, bool isDirectory) {
    if (!m_gridCtrl || !m_gridSizer)
        return;
 
    // Calculate panel size and text size based on icon size
    int panelWidth = m_gridIconSize + 40; // Icon + padding
    // Adjust height based on icon size to accommodate larger text
    int textPadding = (m_gridIconSize == 48) ? 40 : ((m_gridIconSize == 80) ? 50 : 60);
    int panelHeight = m_gridIconSize + textPadding; // Icon + label + padding
 
    // Create a panel for this item
    wxPanel *itemPanel = new wxPanel(m_gridCtrl, wxID_ANY, wxDefaultPosition, wxSize(panelWidth, panelHeight));
    itemPanel->SetBackgroundColour(wxColour(50, 50, 50));
    itemPanel->SetToolTip(name); // Show full name on hover
 
    wxBoxSizer *itemSizer = new wxBoxSizer(wxVERTICAL);
 
    // Determine icon type (use fullPath to get extension, even if name has extension stripped)
    wxString iconType = isDirectory ? "folder" : "file";
    if (!isDirectory) {
        wxString ext = wxFileName(fullPath).GetExt().Lower();
        if (ext == "xml")
            iconType = "xml";
        else if (ext == "json")
            iconType = "json";
        else if (ext == "txt")
            iconType = "txt";
        else if (ext == "png" || ext == "jpg" || ext == "jpeg")
            iconType = "png";
        else if (ext == "md" || ext == "markdown")
            iconType = "markdown";
    }
 
    // Load and add icon (use dynamic icon size from preferences)
    wxBitmap icon = LoadGridIcon(iconType, wxSize(m_gridIconSize, m_gridIconSize));
    wxStaticBitmap *iconCtrl = new wxStaticBitmap(itemPanel, wxID_ANY, icon);
    iconCtrl->SetToolTip(name); // Tooltip on icon too
    itemSizer->Add(iconCtrl, 0, wxALIGN_CENTER | wxALL, 5);
 
    // Add label with smart ellipsization and font size based on icon size
    int labelWidth = panelWidth - 10; // Panel width minus padding
    wxStaticText *label = new wxStaticText(itemPanel, wxID_ANY, name, wxDefaultPosition, wxSize(labelWidth, -1),
                                           wxST_ELLIPSIZE_END | wxALIGN_CENTER_HORIZONTAL);
    label->SetForegroundColour(wxColour(200, 200, 200));
 
    // Scale font size based on icon size
    wxFont labelFont = label->GetFont();
    if (m_gridIconSize == 48) {
        // Small icons: smaller font
        labelFont = labelFont.Smaller();
    } else if (m_gridIconSize == 80) {
        // Medium icons: normal font (no change)
        // labelFont stays as is
    } else if (m_gridIconSize == 128) {
        // Large icons: larger font
        labelFont = labelFont.Larger();
    }
    label->SetFont(labelFont);
    label->SetToolTip(name); // Tooltip on label too
    itemSizer->Add(label, 0, wxALIGN_CENTER | wxALL, 2);
 
    itemPanel->SetSizer(itemSizer);
 
    // Bind events
    itemPanel->Bind(wxEVT_LEFT_DOWN, &FileExplorerTab::OnGridItemMouseDown, this);
    itemPanel->Bind(wxEVT_LEFT_UP, &FileExplorerTab::OnGridItemMouseUp, this);
    itemPanel->Bind(wxEVT_MOTION, &FileExplorerTab::OnGridItemMouseMove, this);
    itemPanel->Bind(wxEVT_LEFT_DCLICK, &FileExplorerTab::OnGridItemDoubleClick, this);
    itemPanel->Bind(wxEVT_RIGHT_DOWN, &FileExplorerTab::OnGridContextMenu, this);
 
    iconCtrl->Bind(wxEVT_LEFT_DOWN, &FileExplorerTab::OnGridItemMouseDown, this);
    iconCtrl->Bind(wxEVT_LEFT_UP, &FileExplorerTab::OnGridItemMouseUp, this);
    iconCtrl->Bind(wxEVT_MOTION, &FileExplorerTab::OnGridItemMouseMove, this);
    iconCtrl->Bind(wxEVT_LEFT_DCLICK, &FileExplorerTab::OnGridItemDoubleClick, this);
    iconCtrl->Bind(wxEVT_RIGHT_DOWN, &FileExplorerTab::OnGridContextMenu, this);
 
    label->Bind(wxEVT_LEFT_DOWN, &FileExplorerTab::OnGridItemMouseDown, this);
    label->Bind(wxEVT_LEFT_UP, &FileExplorerTab::OnGridItemMouseUp, this);
    label->Bind(wxEVT_MOTION, &FileExplorerTab::OnGridItemMouseMove, this);
    label->Bind(wxEVT_LEFT_DCLICK, &FileExplorerTab::OnGridItemDoubleClick, this);
    label->Bind(wxEVT_RIGHT_DOWN, &FileExplorerTab::OnGridContextMenu, this);
 
    // Store client data for event handling
    itemPanel->SetClientData(new FileTreeItemData(fullPath, isDirectory));
 
    // Add with fixed positioning - no stretch, just natural spacing
    m_gridSizer->Add(itemPanel, 0, wxALL, 5);
 
    // Track the item
    GridItem gridItem;
    gridItem.name = name;
    gridItem.fullPath = fullPath;
    gridItem.isDirectory = isDirectory;
    gridItem.widget = itemPanel;
    m_gridItems.push_back(gridItem);
}
 
// ============================================================================
// Event Handlers - Grid
// ============================================================================
 
void FileExplorerTab::OnGridItemDoubleClick(wxMouseEvent &event) {
    wxWindow *window = dynamic_cast<wxWindow *>(event.GetEventObject());
    if (!window) {
        event.Skip();
        return;
    }
 
    // Get the top-level panel
    wxWindow *panelWindow = window;
    while (panelWindow && panelWindow->GetParent() != m_gridCtrl) {
        panelWindow = panelWindow->GetParent();
    }
 
    // Make sure we found a valid panel with client data
    if (panelWindow && panelWindow->GetClientData()) {
        FileTreeItemData *data = static_cast<FileTreeItemData *>(panelWindow->GetClientData());
        if (data != nullptr) {
            if (data->IsDirectory()) {
                // Navigate into folder - use CallAfter to avoid destroying the widget
                // while we're still processing its event
                wxString path = data->GetPath();
                LOG_INFO("FileExplorer", "Navigating to: " + path.ToStdString());
                m_panel->CallAfter([this, path]() { NavigateToPath(path); });
                return; // Don't call event.Skip() since we're handling this
            } else {
                // File activated - could trigger open/load
                LOG_INFO("FileExplorer", "File activated: " + data->GetPath().ToStdString());
            }
        }
    }
 
    event.Skip();
}
 
void FileExplorerTab::OnGridItemMouseDown(wxMouseEvent &event) {
    wxWindow *window = dynamic_cast<wxWindow *>(event.GetEventObject());
    if (!window) {
        event.Skip();
        return;
    }
 
    // Get the top-level panel (might be clicking on icon or label)
    wxWindow *panelWindow = window;
    while (panelWindow && panelWindow->GetParent() != m_gridCtrl) {
        panelWindow = panelWindow->GetParent();
    }
 
    // Make sure we found a valid panel with client data
    if (panelWindow && panelWindow->GetClientData()) {
        FileTreeItemData *data = static_cast<FileTreeItemData *>(panelWindow->GetClientData());
        if (data != nullptr) {
            LOG_INFO("FileExplorer", "Grid item clicked: " + data->GetPath().ToStdString());
 
            // Clear previous selection
            if (m_selectedGridItem && m_selectedGridItem != panelWindow) {
                m_selectedGridItem->SetBackgroundColour(wxColour(50, 50, 50));
                m_selectedGridItem->Refresh();
            }
 
            // Highlight new selection
            panelWindow->SetBackgroundColour(EmberForge::AppPreferencesManager::GetAccentColor());
            panelWindow->Refresh();
            m_selectedGridItem = panelWindow;
 
            // Prepare for potential drag operation
            m_dragStartPos = event.GetPosition();
            m_dragWindow = panelWindow;
        }
    }
 
    event.Skip();
}
 
void FileExplorerTab::OnGridItemMouseMove(wxMouseEvent &event) {
    if (!event.LeftIsDown() || !m_dragWindow) {
        event.Skip();
        return;
    }
 
    // Check if we've moved enough to start a drag
    wxPoint currentPos = event.GetPosition();
    int dx = abs(currentPos.x - m_dragStartPos.x);
    int dy = abs(currentPos.y - m_dragStartPos.y);
 
    if (!m_isDragging && (dx > 3 || dy > 3)) {
        // Start the drag operation
        FileTreeItemData *data = static_cast<FileTreeItemData *>(m_dragWindow->GetClientData());
        if (!data) {
            event.Skip();
            return;
        }
 
        // Only allow dragging files, not directories
        if (data->IsDirectory()) {
            LOG_INFO("FileExplorer", "Cannot drag directories");
            m_dragWindow = nullptr;
            event.Skip();
            return;
        }
 
        wxString filePath = data->GetPath();
 
        // Only allow dragging XML files
        if (!filePath.Lower().EndsWith(".xml")) {
            LOG_INFO("FileExplorer", "Only XML files can be dragged");
            m_dragWindow = nullptr;
            event.Skip();
            return;
        }
 
        m_isDragging = true;
        LOG_INFO("FileExplorer", "Starting drag for file: " + filePath.ToStdString());
 
        // Create a file data object with the file path
        wxFileDataObject fileData;
        fileData.AddFile(filePath);
 
        // Create a drop source and begin the drag operation
        wxDropSource dragSource(fileData, m_gridCtrl);
        wxDragResult result = dragSource.DoDragDrop(wxDrag_DefaultMove);
 
        // Log the result
        switch (result) {
        case wxDragCopy:
            LOG_INFO("FileExplorer", "File copied");
            break;
        case wxDragMove:
            LOG_INFO("FileExplorer", "File moved");
            break;
        case wxDragCancel:
            LOG_INFO("FileExplorer", "Drag cancelled");
            break;
        default:
            LOG_INFO("FileExplorer", "Drag completed with unknown result");
            break;
        }
 
        // Reset drag state
        m_isDragging = false;
        m_dragWindow = nullptr;
    }
 
    event.Skip();
}
 
void FileExplorerTab::OnGridItemMouseUp(wxMouseEvent &event) {
    // Reset drag state
    m_isDragging = false;
    m_dragWindow = nullptr;
 
    event.Skip();
}
 
// ============================================================================
// Event Handlers - Favorites/Filter
// ============================================================================
 
void FileExplorerTab::OnFavoriteFilter(wxCommandEvent &event) {
    wxObject *source = event.GetEventObject();
 
    // Determine which button was clicked
    wxString newFilter = "";
    if (source == m_xmlFilterBtn) {
        if (m_xmlFilterBtn->GetValue()) {
            newFilter = ".xml";
            m_pngFilterBtn->SetValue(false);
            m_jsonFilterBtn->SetValue(false);
        }
    } else if (source == m_pngFilterBtn) {
        if (m_pngFilterBtn->GetValue()) {
            newFilter = ".png";
            m_xmlFilterBtn->SetValue(false);
            m_jsonFilterBtn->SetValue(false);
        }
    } else if (source == m_jsonFilterBtn) {
        if (m_jsonFilterBtn->GetValue()) {
            newFilter = ".json";
            m_xmlFilterBtn->SetValue(false);
            m_pngFilterBtn->SetValue(false);
        }
    }
 
    // Update filter and refresh tree
    m_activeFilter = newFilter;
    LOG_INFO("FileExplorer",
             "Filter changed to: " + (m_activeFilter.IsEmpty() ? "none" : m_activeFilter.ToStdString()));
    PopulateTree();
 
    // Highlight active button
    if (m_xmlFilterBtn && m_xmlFilterBtn->GetValue()) {
        m_xmlFilterBtn->SetBackgroundColour(EmberForge::AppPreferencesManager::GetAccentColor());
    } else if (m_xmlFilterBtn) {
        m_xmlFilterBtn->SetBackgroundColour(wxColour(55, 55, 55));
    }
 
    if (m_pngFilterBtn && m_pngFilterBtn->GetValue()) {
        m_pngFilterBtn->SetBackgroundColour(EmberForge::AppPreferencesManager::GetAccentColor());
    } else if (m_pngFilterBtn) {
        m_pngFilterBtn->SetBackgroundColour(wxColour(55, 55, 55));
    }
 
    if (m_jsonFilterBtn && m_jsonFilterBtn->GetValue()) {
        m_jsonFilterBtn->SetBackgroundColour(EmberForge::AppPreferencesManager::GetAccentColor());
    } else if (m_jsonFilterBtn) {
        m_jsonFilterBtn->SetBackgroundColour(wxColour(55, 55, 55));
    }
}
 
// ============================================================================
// Event Handlers - View Toggle
// ============================================================================
 
void FileExplorerTab::OnTreeToggle(wxCommandEvent &event) {
    m_treeVisible = m_treeToggleBtn->GetValue();
 
    // Ensure at least one view is visible - if trying to hide tree and grid is already hidden, enable grid
    if (!m_treeVisible && !m_gridVisible) {
        m_gridVisible = true;
        m_gridToggleBtn->SetValue(true);
    }
 
    UpdateViewVisibility();
    UpdateToggleButtonAppearance();
 
    LOG_INFO("FileExplorer", "Tree visibility: " + std::string(m_treeVisible ? "on" : "off"));
}
 
void FileExplorerTab::OnGridToggle(wxCommandEvent &event) {
    m_gridVisible = m_gridToggleBtn->GetValue();
 
    // Ensure at least one view is visible - if trying to hide grid and tree is already hidden, enable tree
    if (!m_gridVisible && !m_treeVisible) {
        m_treeVisible = true;
        m_treeToggleBtn->SetValue(true);
    }
 
    UpdateViewVisibility();
    UpdateToggleButtonAppearance();
 
    LOG_INFO("FileExplorer", "Grid visibility: " + std::string(m_gridVisible ? "on" : "off"));
}
 
void FileExplorerTab::UpdateToggleButtonAppearance() {
    if (!m_treeToggleBtn || !m_gridToggleBtn)
        return;
 
    // Sync button values with actual visibility state
    m_treeToggleBtn->SetValue(m_treeVisible);
    m_gridToggleBtn->SetValue(m_gridVisible);
 
    // Update tree button appearance
    if (m_treeVisible) {
        m_treeToggleBtn->SetBackgroundColour(EmberForge::AppPreferencesManager::GetAccentColor()); // Active
    } else {
        m_treeToggleBtn->SetBackgroundColour(wxColour(55, 55, 55)); // Inactive - gray
    }
    m_treeToggleBtn->Refresh();
 
    // Update grid button appearance
    if (m_gridVisible) {
        m_gridToggleBtn->SetBackgroundColour(EmberForge::AppPreferencesManager::GetAccentColor()); // Active
    } else {
        m_gridToggleBtn->SetBackgroundColour(wxColour(55, 55, 55)); // Inactive - gray
    }
    m_gridToggleBtn->Refresh();
}
 
void FileExplorerTab::OnSplitterSashPosChanged(wxSplitterEvent &event) {
    SyncToolbarWithSplitter();
    event.Skip();
}
 
void FileExplorerTab::OnSplitterSashPosChanging(wxSplitterEvent &event) {
    SyncToolbarWithSplitter();
    event.Skip();
}
 
void FileExplorerTab::SyncToolbarWithSplitter() {
    if (!m_splitter || !m_treeSearchCtrl)
        return;
 
    // Get the splitter sash position (width of left panel)
    int sashPos = m_splitter->GetSashPosition();
 
    // Account for margins/padding (the search control has 2px margin on each side)
    // Also account for the splitter itself starting after toolbar panel margin
    int searchWidth = sashPos - 8; // Adjust for margins
 
    // Clamp to reasonable minimum width
    if (searchWidth < 100)
        searchWidth = 100;
    if (searchWidth > 500)
        searchWidth = 500;
 
    // Only update if width actually changed
    wxSize currentSize = m_treeSearchCtrl->GetSize();
    if (currentSize.GetWidth() != searchWidth) {
        m_treeSearchCtrl->SetMinSize(wxSize(searchWidth, -1));
        m_treeSearchCtrl->SetSize(wxSize(searchWidth, currentSize.GetHeight()));
 
        // Force layout update of parent
        wxWindow *parent = m_treeSearchCtrl->GetParent();
        if (parent) {
            parent->Layout();
            parent->Refresh();
        }
    }
}
 
void FileExplorerTab::UpdateBreadcrumbVisibility() {
    if (!m_breadcrumbPanel)
        return;
 
    // Show/hide the breadcrumb path only
    // Keep navigation buttons (back/forward) and grid search visible
    if (m_showBreadcrumb) {
        m_breadcrumbPanel->Show();
    } else {
        m_breadcrumbPanel->Hide();
    }
 
    // Force layout update
    if (m_breadcrumbContainerPanel) {
        m_breadcrumbContainerPanel->Layout();
    }
    if (m_rightPanel) {
        m_rightPanel->Layout();
    }
    m_panel->Layout();
}
 
void FileExplorerTab::UpdateHistoryVisibility() {
    if (!m_functionalPanel)
        return;
 
    // Show/hide the history button (in functional panel)
    if (m_showHistory) {
        m_functionalPanel->Show();
    } else {
        m_functionalPanel->Hide();
    }
 
    // Force layout update
    if (m_breadcrumbContainerPanel) {
        m_breadcrumbContainerPanel->Layout();
    }
    if (m_rightPanel) {
        m_rightPanel->Layout();
    }
    m_panel->Layout();
}
 
void FileExplorerTab::UpdateTreeImageList() {
    if (!m_treeCtrl)
        return;
 
    // Get the current image list (if any) to check if size changed
    wxImageList *oldImageList = m_treeCtrl->GetImageList();
    int oldSize = oldImageList ? oldImageList->GetSize().GetWidth() : -1;
 
    // Only rebuild if size changed
    if (oldSize == m_treeItemSize) {
        return;
    }
 
    LOG_INFO("FileExplorer",
             wxString::Format("Updating tree image list size from %d to %d", oldSize, m_treeItemSize).ToStdString());
 
    // Create new image list with updated size
    wxImageList *newImageList = new wxImageList(m_treeItemSize, m_treeItemSize);
 
    // Reload icons at new size
    wxIcon folderIcon = LoadTreeIcon("folder");
    wxIcon fileIcon = LoadTreeIcon("file");
 
    if (folderIcon.IsOk()) {
        m_folderIcon = newImageList->Add(folderIcon);
    }
    if (fileIcon.IsOk()) {
        m_fileIcon = newImageList->Add(fileIcon);
    }
 
    // Assign new image list (tree takes ownership)
    m_treeCtrl->AssignImageList(newImageList);
 
    // Update tree spacing based on new size
    int spacing = m_treeItemSize + (m_treeItemSize == 16 ? 4 : (m_treeItemSize == 24 ? 6 : 8));
    m_treeCtrl->SetSpacing(spacing);
 
    // Force tree to refresh with new image list
    m_treeCtrl->Refresh();
}
 
void FileExplorerTab::UpdateViewVisibility() {
    if (!m_splitter || !m_leftPanel || !m_rightPanel)
        return;
 
    // First, unsplit if currently split
    if (m_splitter->IsSplit()) {
        // Determine which panel to keep based on what will be visible
        if (m_treeVisible && m_gridVisible) {
            // Both visible - keep split, nothing to do here
        } else if (m_treeVisible) {
            m_splitter->Unsplit(m_rightPanel);
        } else if (m_gridVisible) {
            m_splitter->Unsplit(m_leftPanel);
        }
    }
 
    // Now handle the visibility
    if (m_treeVisible && m_gridVisible) {
        // Show both panels in split view
        m_leftPanel->Show();
        m_rightPanel->Show();
        if (!m_splitter->IsSplit()) {
            m_splitter->SplitVertically(m_leftPanel, m_rightPanel, 200);
        }
    } else if (m_treeVisible && !m_gridVisible) {
        // Show only tree
        m_rightPanel->Hide();
        m_leftPanel->Show();
        // Replace the splitter content with just the left panel
        if (!m_splitter->IsSplit()) {
            m_splitter->Initialize(m_leftPanel);
        }
    } else if (!m_treeVisible && m_gridVisible) {
        // Show only grid
        m_leftPanel->Hide();
        m_rightPanel->Show();
        // Replace the splitter content with just the right panel
        if (!m_splitter->IsSplit()) {
            m_splitter->Initialize(m_rightPanel);
        }
    }
 
    m_splitter->Layout();
    m_panel->Layout();
    m_panel->Refresh();
}
 
// ============================================================================
// Event Handlers - Breadcrumb
// ============================================================================
 
void FileExplorerTab::OnBreadcrumbClick(wxCommandEvent &event) {
    // Close history panel if it's open
    if (m_isHistoryVisible) {
        ToggleHistoryView();
    }
 
    wxButton *btn = dynamic_cast<wxButton *>(event.GetEventObject());
    if (btn) {
        // Safely get the path from client data
        wxString *pathPtr = static_cast<wxString *>(btn->GetClientData());
        if (pathPtr && wxDirExists(*pathPtr)) {
            wxString pathCopy = *pathPtr; // Make a copy before navigating
            NavigateToPath(pathCopy);
        }
    }
}
 
// ============================================================================
// Helper Methods
// ============================================================================
 
void FileExplorerTab::NavigateToPath(const wxString &path, bool recordHistory) {
    if (!wxDir::Exists(path)) {
        LOG_ERROR("FileExplorer", "Cannot navigate to non-existent path: " + path.ToStdString());
        return;
    }
 
    // Store previous path for activity log
    wxString previousPath = m_currentGridPath;
 
    // Add current path to navigation history if requested (and we're not already navigating via history)
    if (recordHistory && !m_isNavigatingHistory && !previousPath.IsEmpty() && previousPath != path) {
        AddToNavigationHistory(previousPath);
    }
 
    m_currentGridPath = path;
    PopulateGrid(path);
    UpdateBreadcrumb();
    // No automatic tree syncing - tree and grid are independent
 
    // Log navigation activity with from -> to format
    if (recordHistory) {
        if (!previousPath.IsEmpty() && previousPath != path) {
            LogActivity(ActivityType::NAVIGATE, path, previousPath + "   ->   " + path);
        } else {
            LogActivity(ActivityType::NAVIGATE, path);
        }
    }
 
    // Update button states after navigation
    if (recordHistory) {
        UpdateNavigationButtons();
    }
}
 
wxTreeItemId FileExplorerTab::FindTreeItemByPath(const wxString &path, wxTreeItemId parent) {
    if (!m_treeCtrl || !parent.IsOk()) {
        // If parent is not provided, start from root
        if (!m_treeCtrl)
            return wxTreeItemId();
        parent = m_treeCtrl->GetRootItem();
        if (!parent.IsOk())
            return wxTreeItemId();
    }
 
    // Check if this item matches the path
    FileTreeItemData *data = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(parent));
    if (data && data->GetPath() == path) {
        return parent;
    }
 
    // Recursively search children
    wxTreeItemIdValue cookie;
    wxTreeItemId child = m_treeCtrl->GetFirstChild(parent, cookie);
 
    while (child.IsOk()) {
        // First check if the child itself matches
        FileTreeItemData *childData = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(child));
        if (childData && childData->GetPath() == path) {
            return child;
        }
 
        // Then recursively search the child's subtree (only if path starts with child's path)
        if (childData && path.StartsWith(childData->GetPath())) {
            wxTreeItemId found = FindTreeItemByPath(path, child);
            if (found.IsOk()) {
                return found;
            }
        }
 
        child = m_treeCtrl->GetNextChild(parent, cookie);
    }
 
    return wxTreeItemId(); // Not found
}
 
void FileExplorerTab::UpdateBreadcrumb() {
    if (!m_breadcrumbSizer || !m_breadcrumbPanel)
        return;
 
    // Delete client data from existing breadcrumb buttons before clearing
    if (m_breadcrumbSizer) {
        for (size_t i = 0; i < m_breadcrumbSizer->GetItemCount(); i++) {
            wxSizerItem *item = m_breadcrumbSizer->GetItem(i);
            if (item && item->IsWindow()) {
                wxButton *btn = dynamic_cast<wxButton *>(item->GetWindow());
                if (btn && btn->GetClientData()) {
                    wxString *pathPtr = static_cast<wxString *>(btn->GetClientData());
                    if (pathPtr) {
                        delete pathPtr;
                        btn->SetClientData(nullptr);
                    }
                }
            }
        }
 
        // Clear all breadcrumb items (navigation buttons are in separate panel, so safe to clear)
        m_breadcrumbSizer->Clear(true);
    }
 
    // Get relative path from root to current grid path
    wxString relativePath = m_currentGridPath;
    if (relativePath.StartsWith(m_rootPath)) {
        relativePath = relativePath.Mid(m_rootPath.Length());
        if (relativePath.StartsWith(wxFileName::GetPathSeparator())) {
            relativePath = relativePath.Mid(1);
        }
    }
 
    // Add root button
    wxButton *rootBtn =
        new wxButton(m_breadcrumbPanel, wxID_ANY, "Resources", wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
    rootBtn->SetBackgroundColour(wxColour(60, 60, 60));
    rootBtn->SetForegroundColour(wxColour(200, 200, 200));
    rootBtn->SetMinSize(wxSize(-1, 32)); // Taller button for better visibility
    wxFont rootFont = rootBtn->GetFont();
    rootFont.SetPointSize(rootFont.GetPointSize() + 1);
    rootBtn->SetFont(rootFont);
    rootBtn->SetClientData(new wxString(m_rootPath));
    rootBtn->Bind(wxEVT_BUTTON, &FileExplorerTab::OnBreadcrumbClick, this);
    m_breadcrumbSizer->Add(rootBtn, 0, wxALIGN_CENTER_VERTICAL | wxALL, 2);
 
    // If we're not at root, add subdirectories
    if (!relativePath.IsEmpty()) {
        wxArrayString pathParts = wxSplit(relativePath, wxFileName::GetPathSeparator());
        wxString currentPath = m_rootPath;
 
        for (size_t i = 0; i < pathParts.GetCount(); i++) {
            if (pathParts[i].IsEmpty())
                continue;
 
            // Add separator
            wxStaticText *separator = new wxStaticText(m_breadcrumbPanel, wxID_ANY, " > ");
            separator->SetForegroundColour(wxColour(150, 150, 150));
            wxFont sepFont = separator->GetFont();
            sepFont.SetPointSize(sepFont.GetPointSize() + 1);
            separator->SetFont(sepFont);
            m_breadcrumbSizer->Add(separator, 0, wxALIGN_CENTER_VERTICAL | wxALL, 2);
 
            // Add directory button
            currentPath += wxFileName::GetPathSeparator() + pathParts[i];
            wxButton *dirBtn = new wxButton(m_breadcrumbPanel, wxID_ANY, pathParts[i], wxDefaultPosition, wxDefaultSize,
                                            wxBU_EXACTFIT);
            dirBtn->SetBackgroundColour(wxColour(60, 60, 60));
            dirBtn->SetForegroundColour(wxColour(200, 200, 200));
            dirBtn->SetMinSize(wxSize(-1, 32)); // Taller button for better visibility
            wxFont dirFont = dirBtn->GetFont();
            dirFont.SetPointSize(dirFont.GetPointSize() + 1);
            dirBtn->SetFont(dirFont);
            dirBtn->SetClientData(new wxString(currentPath));
            dirBtn->Bind(wxEVT_BUTTON, &FileExplorerTab::OnBreadcrumbClick, this);
            m_breadcrumbSizer->Add(dirBtn, 0, wxALIGN_CENTER_VERTICAL | wxALL, 2);
        }
    }
 
    m_breadcrumbPanel->Layout();
    m_breadcrumbPanel->Refresh();
}
 
bool FileExplorerTab::PassesFilter(const wxString &filename) const {
    if (m_activeFilter.IsEmpty()) {
        return true; // No filter, show all
    }
 
    wxString ext = wxFileName(filename).GetExt().Lower();
 
    if (m_activeFilter == ".xml") {
        return ext == "xml";
    } else if (m_activeFilter == ".png") {
        return ext == "png" || ext == "jpg" || ext == "jpeg";
    } else if (m_activeFilter == ".json") {
        return ext == "json";
    }
 
    return false;
}
 
bool FileExplorerTab::DirectoryContainsFilteredFiles(const wxString &path) const {
    // If no filter is active, all directories are valid
    if (m_activeFilter.IsEmpty()) {
        return true;
    }
 
    if (!wxDir::Exists(path)) {
        return false;
    }
 
    wxDir dir(path);
    if (!dir.IsOpened()) {
        return false;
    }
 
    // Check files in current directory
    wxString filename;
    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES);
    while (cont) {
        if (!filename.StartsWith(".") && PassesFilter(filename)) {
            return true; // Found a matching file
        }
        cont = dir.GetNext(&filename);
    }
 
    // Recursively check subdirectories
    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
    while (cont) {
        if (!filename.StartsWith(".")) {
            wxString fullPath = path + wxFileName::GetPathSeparator() + filename;
            if (DirectoryContainsFilteredFiles(fullPath)) {
                return true; // Found matching files in subdirectory
            }
        }
        cont = dir.GetNext(&filename);
    }
 
    return false; // No matching files found in this directory or its subdirectories
}
 
// ============================================================================
// Context Menu Event Handlers
// ============================================================================
 
void FileExplorerTab::OnTreeContextMenu(wxTreeEvent &event) {
    wxTreeItemId item = event.GetItem();
    if (!item.IsOk()) {
        return;
    }
 
    // Select the item that was right-clicked
    m_treeCtrl->SelectItem(item);
 
    // Get the item data
    FileTreeItemData *data = dynamic_cast<FileTreeItemData *>(m_treeCtrl->GetItemData(item));
    if (!data) {
        return;
    }
 
    // Only show context menu for directories
    if (!data->IsDirectory()) {
        LOG_INFO("FileExplorer", "Context menu only available for folders");
        return;
    }
 
    wxString folderPath = data->GetPath();
    LOG_INFO("FileExplorer", "Tree context menu for: " + folderPath.ToStdString());
 
    // Store the path for use in menu handlers
    m_contextMenuPath = folderPath;
 
    // Create the context menu
    wxMenu contextMenu;
    contextMenu.Append(ID_CONTEXT_OPEN, "Open");
    contextMenu.AppendSeparator();
    contextMenu.Append(ID_CONTEXT_RENAME, "Rename");
    contextMenu.Append(ID_CONTEXT_DELETE, "Delete");
    contextMenu.AppendSeparator();
    contextMenu.Append(ID_CONTEXT_COPY, "Copy");
    contextMenu.Append(ID_CONTEXT_CUT, "Cut");
    contextMenu.Append(ID_CONTEXT_PASTE, "Paste");
    contextMenu.AppendSeparator();
    contextMenu.Append(ID_CONTEXT_REFRESH, "Refresh");
    contextMenu.AppendSeparator();
    contextMenu.Append(ID_CONTEXT_PROPERTIES, "Properties");
 
    // Enable/disable paste based on clipboard state
    contextMenu.Enable(ID_CONTEXT_PASTE, !m_clipboardPath.IsEmpty());
 
    // Bind menu events
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuOpen, this, ID_CONTEXT_OPEN);
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuRename, this, ID_CONTEXT_RENAME);
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuDelete, this, ID_CONTEXT_DELETE);
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuCopy, this, ID_CONTEXT_COPY);
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuCut, this, ID_CONTEXT_CUT);
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuPaste, this, ID_CONTEXT_PASTE);
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuRefresh, this, ID_CONTEXT_REFRESH);
    contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuProperties, this, ID_CONTEXT_PROPERTIES);
 
    // Show the menu on the tree control at the mouse position
    m_treeCtrl->PopupMenu(&contextMenu);
}
 
void FileExplorerTab::OnGridBackgroundContextMenu(wxMouseEvent &event) {
    // This handler is for clicks on the grid background (empty space)
    // Check if we actually clicked on empty space or on a grid item
    wxWindow *window = dynamic_cast<wxWindow *>(event.GetEventObject());
 
    // If the click was on the grid control itself (not a child panel), show background menu
    if (window == m_gridCtrl) {
        LOG_INFO("FileExplorer", "Grid background context menu");
 
        // Create context menu for empty space
        wxMenu contextMenu;
        contextMenu.Append(ID_CONTEXT_NEW_FOLDER, "New Folder");
        contextMenu.Append(ID_CONTEXT_PASTE, "Paste");
        contextMenu.AppendSeparator();
        contextMenu.Append(ID_CONTEXT_REFRESH, "Refresh");
 
        // Enable/disable paste based on clipboard state
        contextMenu.Enable(ID_CONTEXT_PASTE, !m_clipboardPath.IsEmpty());
 
        // Set context path to current grid directory
        m_contextMenuPath = m_currentGridPath;
 
        // Bind menu events
        contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuNewFolder, this, ID_CONTEXT_NEW_FOLDER);
        contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuPaste, this, ID_CONTEXT_PASTE);
        contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuRefresh, this, ID_CONTEXT_REFRESH);
 
        // Show the menu
        m_gridCtrl->PopupMenu(&contextMenu);
    } else {
        // Click was on a child element, don't handle it here
        event.Skip();
    }
}
 
void FileExplorerTab::OnGridContextMenu(wxMouseEvent &event) {
    wxWindow *window = dynamic_cast<wxWindow *>(event.GetEventObject());
    if (!window) {
        event.Skip();
        return;
    }
 
    // Get the top-level panel
    wxWindow *panelWindow = window;
    while (panelWindow && panelWindow->GetParent() != m_gridCtrl) {
        panelWindow = panelWindow->GetParent();
    }
 
    // Make sure we found a valid panel with client data
    if (panelWindow && panelWindow->GetClientData()) {
        FileTreeItemData *data = static_cast<FileTreeItemData *>(panelWindow->GetClientData());
        if (data != nullptr) {
            wxString itemPath = data->GetPath();
            bool isDirectory = data->IsDirectory();
 
            LOG_INFO("FileExplorer",
                     wxString::Format("Grid context menu for %s: %s", isDirectory ? "folder" : "file", itemPath)
                         .ToStdString());
 
            // Highlight the selected item visually
            if (m_selectedGridItem && m_selectedGridItem != panelWindow) {
                m_selectedGridItem->SetBackgroundColour(wxColour(50, 50, 50));
                m_selectedGridItem->Refresh();
            }
            m_selectedGridItem = panelWindow;
            panelWindow->SetBackgroundColour(wxColour(70, 90, 120));
            panelWindow->Refresh();
 
            // Store the path for use in menu handlers
            m_contextMenuPath = itemPath;
 
            // Create the context menu
            wxMenu contextMenu;
 
            if (isDirectory) {
                // Folder context menu
                contextMenu.Append(ID_CONTEXT_OPEN, "Open");
                contextMenu.AppendSeparator();
                contextMenu.Append(ID_CONTEXT_RENAME, "Rename");
                contextMenu.Append(ID_CONTEXT_DELETE, "Delete");
                contextMenu.AppendSeparator();
                contextMenu.Append(ID_CONTEXT_COPY, "Copy");
                contextMenu.Append(ID_CONTEXT_CUT, "Cut");
                contextMenu.Append(ID_CONTEXT_PASTE, "Paste");
                contextMenu.AppendSeparator();
                contextMenu.Append(ID_CONTEXT_REFRESH, "Refresh");
                contextMenu.AppendSeparator();
                contextMenu.Append(ID_CONTEXT_PROPERTIES, "Properties");
 
                // Enable/disable paste based on clipboard state
                contextMenu.Enable(ID_CONTEXT_PASTE, !m_clipboardPath.IsEmpty());
            } else {
                // File context menu
                contextMenu.Append(ID_CONTEXT_OPEN, "Open");
                contextMenu.AppendSeparator();
                contextMenu.Append(ID_CONTEXT_RENAME, "Rename");
                contextMenu.Append(ID_CONTEXT_DELETE, "Delete");
                contextMenu.AppendSeparator();
                contextMenu.Append(ID_CONTEXT_COPY, "Copy");
                contextMenu.Append(ID_CONTEXT_CUT, "Cut");
                contextMenu.AppendSeparator();
                contextMenu.Append(ID_CONTEXT_PROPERTIES, "Properties");
            }
 
            // Bind menu events
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuOpen, this, ID_CONTEXT_OPEN);
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuRename, this, ID_CONTEXT_RENAME);
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuDelete, this, ID_CONTEXT_DELETE);
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuCopy, this, ID_CONTEXT_COPY);
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuCut, this, ID_CONTEXT_CUT);
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuPaste, this, ID_CONTEXT_PASTE);
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuRefresh, this, ID_CONTEXT_REFRESH);
            contextMenu.Bind(wxEVT_MENU, &FileExplorerTab::OnContextMenuProperties, this, ID_CONTEXT_PROPERTIES);
 
            // Show the menu on the grid control at the mouse position
            m_gridCtrl->PopupMenu(&contextMenu);
 
            // Don't skip the event - we handled it by showing the context menu
            return;
        }
    }
 
    // Only skip if we didn't handle the event (no valid panel/data found)
    event.Skip();
}
 
void FileExplorerTab::OnContextMenuOpen(wxCommandEvent &event) {
    if (m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    // Store path before deferring (m_contextMenuPath might change)
    wxString pathToOpen = m_contextMenuPath;
 
    if (wxDir::Exists(pathToOpen)) {
        // It's a folder - navigate into it
        LOG_INFO("FileExplorer", "Opening folder: " + pathToOpen.ToStdString());
 
        // Defer navigation to after menu event is fully processed
        // This prevents segfault from destroying widgets while menu is still active
        m_panel->CallAfter([this, pathToOpen]() { NavigateToPath(pathToOpen); });
    } else if (wxFileExists(pathToOpen)) {
        // It's a file - open it
        LOG_INFO("FileExplorer", "Opening file: " + pathToOpen.ToStdString());
 
        // Defer to after menu event processing
        m_panel->CallAfter([this, pathToOpen]() { OpenFile(pathToOpen); });
    }
}
 
void FileExplorerTab::OnContextMenuNewFolder(wxCommandEvent &event) {
    if (m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    LOG_INFO("FileExplorer", "Create new folder in: " + m_contextMenuPath.ToStdString());
 
    // Show input dialog for folder name
    wxTextEntryDialog dialog(m_panel, "Enter folder name:", "New Folder", "New Folder");
 
    if (dialog.ShowModal() == wxID_OK) {
        wxString folderName = dialog.GetValue().Trim();
 
        if (folderName.IsEmpty()) {
            wxMessageBox("Folder name cannot be empty", "Error", wxOK | wxICON_ERROR, m_panel);
            return;
        }
 
        // Create the folder
        if (CreateNewFolder(m_contextMenuPath, folderName)) {
            // Refresh the views
            PopulateTree();
            PopulateGrid(m_currentGridPath);
            LOG_INFO("FileExplorer", "Folder created successfully: " + folderName.ToStdString());
        }
    }
}
 
void FileExplorerTab::OnContextMenuRename(wxCommandEvent &event) {
    if (m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    wxFileName fn(m_contextMenuPath);
    wxString oldName = fn.GetFullName();
    bool isDirectory = wxDir::Exists(m_contextMenuPath);
 
    LOG_INFO("FileExplorer",
             wxString::Format("Rename %s: %s", isDirectory ? "folder" : "file", m_contextMenuPath).ToStdString());
 
    // Show input dialog for new name
    wxTextEntryDialog dialog(m_panel, "Enter new name:", isDirectory ? "Rename Folder" : "Rename File", oldName);
 
    if (dialog.ShowModal() == wxID_OK) {
        wxString newName = dialog.GetValue().Trim();
 
        if (newName.IsEmpty()) {
            wxMessageBox(wxString::Format("%s name cannot be empty", isDirectory ? "Folder" : "File"), "Error",
                         wxOK | wxICON_ERROR, m_panel);
            return;
        }
 
        if (newName == oldName) {
            return; // No change
        }
 
        bool success = false;
        if (isDirectory) {
            success = RenameFolder(m_contextMenuPath, newName);
            if (success) {
                // Update current grid path if we renamed the current directory
                wxString newPath = fn.GetPath() + wxFileName::GetPathSeparator() + newName;
                if (m_currentGridPath == m_contextMenuPath) {
                    m_currentGridPath = newPath;
                }
            }
        } else {
            success = RenameFile(m_contextMenuPath, newName);
        }
 
        if (success) {
            // Refresh the views
            PopulateTree();
            PopulateGrid(m_currentGridPath);
            UpdateBreadcrumb();
            LOG_INFO("FileExplorer",
                     wxString::Format("%s renamed successfully to: %s", isDirectory ? "Folder" : "File", newName)
                         .ToStdString());
        }
    }
}
 
void FileExplorerTab::OnContextMenuDelete(wxCommandEvent &event) {
    if (m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    wxFileName fn(m_contextMenuPath);
    wxString itemName = fn.GetFullName();
    bool isDirectory = wxDir::Exists(m_contextMenuPath);
 
    LOG_INFO(
        "FileExplorer",
        wxString::Format("Delete %s request: %s", isDirectory ? "folder" : "file", m_contextMenuPath).ToStdString());
 
    // Show confirmation dialog
    wxString message;
    if (isDirectory) {
        message = wxString::Format(
            "Are you sure you want to delete the folder '%s' and all its contents?\n\nThis action cannot be undone.",
            itemName);
    } else {
        message = wxString::Format("Are you sure you want to delete the file '%s'?\n\nThis action cannot be undone.",
                                   itemName);
    }
    wxMessageDialog confirmDialog(m_panel, message, "Confirm Delete", wxYES_NO | wxNO_DEFAULT | wxICON_WARNING);
 
    if (confirmDialog.ShowModal() == wxID_YES) {
        bool success = false;
        if (isDirectory) {
            success = DeleteFolder(m_contextMenuPath);
            if (success) {
                // If we deleted the current directory, navigate to parent
                if (m_currentGridPath == m_contextMenuPath ||
                    m_currentGridPath.StartsWith(m_contextMenuPath + wxFileName::GetPathSeparator())) {
                    wxString parentPath = fn.GetPath();
                    if (!parentPath.IsEmpty()) {
                        m_currentGridPath = parentPath;
                    } else {
                        m_currentGridPath = m_rootPath;
                    }
                }
            }
        } else {
            success = DeleteFile(m_contextMenuPath);
        }
 
        if (success) {
            // Refresh the views
            PopulateTree();
            PopulateGrid(m_currentGridPath);
            UpdateBreadcrumb();
            LOG_INFO("FileExplorer",
                     wxString::Format("%s deleted successfully: %s", isDirectory ? "Folder" : "File", itemName)
                         .ToStdString());
        }
    }
}
 
void FileExplorerTab::OnContextMenuCopy(wxCommandEvent &event) {
    if (m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    bool isDirectory = wxDir::Exists(m_contextMenuPath);
    LOG_INFO("FileExplorer",
             wxString::Format("Copy %s: %s", isDirectory ? "folder" : "file", m_contextMenuPath).ToStdString());
 
    // Store in clipboard
    m_clipboardPath = m_contextMenuPath;
    m_clipboardIsCut = false;
 
    wxFileName fn(m_contextMenuPath);
    wxString itemName = fn.GetFullName();
    LOG_INFO("FileExplorer",
             wxString::Format("%s '%s' copied to clipboard", isDirectory ? "Folder" : "File", itemName).ToStdString());
    LogActivity(ActivityType::COPY, m_contextMenuPath, itemName);
}
 
void FileExplorerTab::OnContextMenuCut(wxCommandEvent &event) {
    if (m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    bool isDirectory = wxDir::Exists(m_contextMenuPath);
    LOG_INFO("FileExplorer",
             wxString::Format("Cut %s: %s", isDirectory ? "folder" : "file", m_contextMenuPath).ToStdString());
 
    // Store in clipboard
    m_clipboardPath = m_contextMenuPath;
    m_clipboardIsCut = true;
 
    wxFileName fn(m_contextMenuPath);
    wxString itemName = fn.GetFullName();
    LOG_INFO("FileExplorer",
             wxString::Format("%s '%s' cut to clipboard", isDirectory ? "Folder" : "File", itemName).ToStdString());
    LogActivity(ActivityType::CUT, m_contextMenuPath, itemName);
}
 
void FileExplorerTab::OnContextMenuPaste(wxCommandEvent &event) {
    if (m_clipboardPath.IsEmpty() || m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    // Paste destination must be a folder
    if (!wxDir::Exists(m_contextMenuPath)) {
        wxMessageBox("Can only paste into folders", "Error", wxOK | wxICON_ERROR, m_panel);
        return;
    }
 
    bool sourceIsDir = wxDir::Exists(m_clipboardPath);
    wxFileName sourceFn(m_clipboardPath);
    wxString sourceName = sourceFn.GetFullName();
    wxString destPath = m_contextMenuPath + wxFileName::GetPathSeparator() + sourceName;
 
    LOG_INFO("FileExplorer", wxString::Format("Paste: %s %s %s to %s", m_clipboardIsCut ? "moving" : "copying",
                                              sourceIsDir ? "folder" : "file", m_clipboardPath, destPath)
                                 .ToStdString());
 
    // Check if source still exists
    bool sourceExists = sourceIsDir ? wxDir::Exists(m_clipboardPath) : wxFileExists(m_clipboardPath);
    if (!sourceExists) {
        wxMessageBox(wxString::Format("Source %s no longer exists", sourceIsDir ? "folder" : "file"), "Error",
                     wxOK | wxICON_ERROR, m_panel);
        m_clipboardPath.Clear();
        return;
    }
 
    // Prevent pasting a folder into itself or its subdirectories
    if (sourceIsDir && m_contextMenuPath.StartsWith(m_clipboardPath)) {
        wxMessageBox("Cannot paste a folder into itself or its subdirectories", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Attempted to paste folder into itself");
        return;
    }
 
    // Check if destination already exists
    bool destExists = sourceIsDir ? wxDir::Exists(destPath) : wxFileExists(destPath);
    if (destExists) {
        wxMessageBox(
            wxString::Format("A %s with this name already exists in the destination", sourceIsDir ? "folder" : "file"),
            "Error", wxOK | wxICON_ERROR, m_panel);
        return;
    }
 
    // Perform the operation
    bool success = false;
    if (m_clipboardIsCut) {
        // Move operation
        if (sourceIsDir) {
            success = MoveFolder(m_clipboardPath, destPath);
        } else {
            success = MoveFile(m_clipboardPath, destPath);
        }
        if (success) {
            wxString sourcePath = m_clipboardPath; // Save before clearing
            m_clipboardPath.Clear();               // Clear clipboard after cut+paste
            LOG_INFO("FileExplorer",
                     wxString::Format("%s moved successfully", sourceIsDir ? "Folder" : "File").ToStdString());
            LogActivity(ActivityType::PASTE, destPath, sourcePath + "   ->   " + destPath + " (moved)");
        }
    } else {
        // Copy operation
        if (sourceIsDir) {
            success = CopyFolder(m_clipboardPath, destPath);
        } else {
            success = CopyFile(m_clipboardPath, destPath);
        }
        if (success) {
            LOG_INFO("FileExplorer",
                     wxString::Format("%s copied successfully", sourceIsDir ? "Folder" : "File").ToStdString());
            LogActivity(ActivityType::PASTE, destPath, m_clipboardPath + "   ->   " + destPath + " (copied)");
            // Keep clipboard for multiple paste operations
        }
    }
 
    if (success) {
        // Refresh views
        PopulateTree();
        PopulateGrid(m_currentGridPath);
        UpdateBreadcrumb();
    }
}
 
void FileExplorerTab::OnContextMenuRefresh(wxCommandEvent &event) {
    LOG_INFO("FileExplorer", "Refreshing file explorer");
 
    // Refresh both tree and grid
    PopulateTree();
    PopulateGrid(m_currentGridPath);
    UpdateBreadcrumb();
 
    wxMessageBox("File explorer refreshed", "Refresh", wxOK | wxICON_INFORMATION, m_panel);
}
 
void FileExplorerTab::OnContextMenuProperties(wxCommandEvent &event) {
    if (m_contextMenuPath.IsEmpty()) {
        return;
    }
 
    bool isDirectory = wxDir::Exists(m_contextMenuPath);
    LOG_INFO("FileExplorer",
             wxString::Format("Show properties for %s: %s", isDirectory ? "folder" : "file", m_contextMenuPath)
                 .ToStdString());
 
    if (isDirectory) {
        ShowFolderProperties(m_contextMenuPath);
    } else {
        ShowFileProperties(m_contextMenuPath);
    }
}
 
// ============================================================================
// Context Menu Helper Methods
// ============================================================================
 
bool FileExplorerTab::CreateNewFolder(const wxString &parentPath, const wxString &folderName) {
    wxString newFolderPath = parentPath + wxFileName::GetPathSeparator() + folderName;
 
    // Check if folder already exists
    if (wxDir::Exists(newFolderPath)) {
        wxMessageBox("A folder with this name already exists", "Error", wxOK | wxICON_ERROR, m_panel);
        return false;
    }
 
    // Create the directory
    if (wxFileName::Mkdir(newFolderPath, wxS_DIR_DEFAULT, 0)) {
        LOG_INFO("FileExplorer", "Created folder: " + newFolderPath.ToStdString());
        LogActivity(ActivityType::CREATE_FOLDER, newFolderPath, folderName);
        return true;
    } else {
        wxMessageBox("Failed to create folder. Check permissions.", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Failed to create folder: " + newFolderPath.ToStdString());
        return false;
    }
}
 
bool FileExplorerTab::RenameFolder(const wxString &oldPath, const wxString &newName) {
    wxFileName fn(oldPath);
    wxString newPath = fn.GetPath() + wxFileName::GetPathSeparator() + newName;
 
    // Check if target already exists
    if (wxDir::Exists(newPath)) {
        wxMessageBox("A folder with this name already exists", "Error", wxOK | wxICON_ERROR, m_panel);
        return false;
    }
 
    // Rename the directory
    if (wxRenameFile(oldPath, newPath, false)) {
        LOG_INFO("FileExplorer",
                 "Renamed folder from '" + oldPath.ToStdString() + "' to '" + newPath.ToStdString() + "'");
        LogActivity(ActivityType::RENAME_FOLDER, newPath, oldPath + "   ->   " + newPath);
        return true;
    } else {
        wxMessageBox("Failed to rename folder. Check permissions.", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Failed to rename folder: " + oldPath.ToStdString());
        return false;
    }
}
 
bool FileExplorerTab::DeleteFolder(const wxString &folderPath) {
    // Use wxFileName::Rmdir to recursively delete
    if (wxFileName::Rmdir(folderPath, wxPATH_RMDIR_RECURSIVE)) {
        LOG_INFO("FileExplorer", "Deleted folder: " + folderPath.ToStdString());
        LogActivity(ActivityType::DELETE_FOLDER, folderPath, wxFileName(folderPath).GetFullName());
        return true;
    } else {
        wxMessageBox("Failed to delete folder. Check permissions or if folder is in use.", "Error", wxOK | wxICON_ERROR,
                     m_panel);
        LOG_ERROR("FileExplorer", "Failed to delete folder: " + folderPath.ToStdString());
        return false;
    }
}
 
void FileExplorerTab::ShowFolderProperties(const wxString &folderPath) {
    if (!wxDir::Exists(folderPath)) {
        wxMessageBox("Folder does not exist", "Error", wxOK | wxICON_ERROR, m_panel);
        return;
    }
 
    wxFileName fn(folderPath);
    wxString folderName = fn.GetFullName().IsEmpty() ? folderPath : fn.GetFullName();
 
    // Get folder information
    wxDateTime modTime;
    if (fn.GetTimes(nullptr, &modTime, nullptr)) {
        // Successfully got modification time
    }
 
    int fileCount = CountFilesInDirectory(folderPath, false);
    int totalCount = CountFilesInDirectory(folderPath, true);
    wxString sizeStr = GetDirectorySize(folderPath);
 
    // Build properties message
    wxString properties;
    properties += "Folder Properties\n";
    properties += "================\n\n";
    properties += "Name: " + folderName + "\n";
    properties += "Location: " + fn.GetPath() + "\n";
    properties += "Full Path: " + folderPath + "\n\n";
    properties += "Files (direct): " + wxString::Format("%d", fileCount) + "\n";
    properties += "Total Items (recursive): " + wxString::Format("%d", totalCount) + "\n";
    properties += "Size: " + sizeStr + "\n\n";
 
    if (modTime.IsValid()) {
        properties += "Modified: " + modTime.Format("%Y-%m-%d %H:%M:%S") + "\n";
    }
 
    // Show in a message box (could be a custom dialog for better UX)
    wxMessageBox(properties, "Folder Properties", wxOK | wxICON_INFORMATION, m_panel);
}
 
wxString FileExplorerTab::GetDirectorySize(const wxString &path) const {
    if (!wxDir::Exists(path)) {
        return "0 bytes";
    }
 
    wxDir dir(path);
    if (!dir.IsOpened()) {
        return "Unknown";
    }
 
    unsigned long long totalSize = 0;
    wxString filename;
 
    // Count files in this directory
    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES);
    while (cont) {
        wxString fullPath = path + wxFileName::GetPathSeparator() + filename;
        wxFileName fn(fullPath);
        totalSize += fn.GetSize().ToULong();
        cont = dir.GetNext(&filename);
    }
 
    // Recursively count subdirectories
    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
    while (cont) {
        if (!filename.StartsWith(".")) {
            // wxString subPath = path + wxFileName::GetPathSeparator() + filename;
            // wxString subSize = GetDirectorySize(subPath);
            // Parse the size (this is simplified, would need better parsing)
            // For now, we'll skip adding subdirectory sizes to keep it simple
        }
        cont = dir.GetNext(&filename);
    }
 
    // Format size nicely
    if (totalSize < 1024) {
        return wxString::Format("%llu bytes", totalSize);
    } else if (totalSize < 1024 * 1024) {
        return wxString::Format("%.2f KB", totalSize / 1024.0);
    } else if (totalSize < 1024 * 1024 * 1024) {
        return wxString::Format("%.2f MB", totalSize / (1024.0 * 1024.0));
    } else {
        return wxString::Format("%.2f GB", totalSize / (1024.0 * 1024.0 * 1024.0));
    }
}
 
int FileExplorerTab::CountFilesInDirectory(const wxString &path, bool recursive) const {
    if (!wxDir::Exists(path)) {
        return 0;
    }
 
    wxDir dir(path);
    if (!dir.IsOpened()) {
        return 0;
    }
 
    int count = 0;
    wxString filename;
 
    // Count files
    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES);
    while (cont) {
        count++;
        cont = dir.GetNext(&filename);
    }
 
    // Count directories
    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
    while (cont) {
        if (!filename.StartsWith(".")) {
            count++; // Count the directory itself
 
            if (recursive) {
                wxString subPath = path + wxFileName::GetPathSeparator() + filename;
                count += CountFilesInDirectory(subPath, true);
            }
        }
        cont = dir.GetNext(&filename);
    }
 
    return count;
}
 
bool FileExplorerTab::CopyFolder(const wxString &sourcePath, const wxString &destPath) {
    if (!wxDir::Exists(sourcePath)) {
        wxMessageBox("Source folder does not exist", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Source folder does not exist: " + sourcePath.ToStdString());
        return false;
    }
 
    // Create destination directory
    if (!wxFileName::Mkdir(destPath, wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL)) {
        wxMessageBox("Failed to create destination folder", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Failed to create destination: " + destPath.ToStdString());
        return false;
    }
 
    wxDir dir(sourcePath);
    if (!dir.IsOpened()) {
        wxMessageBox("Cannot open source folder", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Cannot open source folder: " + sourcePath.ToStdString());
        return false;
    }
 
    wxString filename;
 
    // Copy all files
    bool cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_FILES);
    while (cont) {
        wxString sourceFile = sourcePath + wxFileName::GetPathSeparator() + filename;
        wxString destFile = destPath + wxFileName::GetPathSeparator() + filename;
 
        if (!wxCopyFile(sourceFile, destFile, false)) {
            wxMessageBox("Failed to copy file: " + filename, "Error", wxOK | wxICON_ERROR, m_panel);
            LOG_ERROR("FileExplorer", "Failed to copy file: " + sourceFile.ToStdString());
            return false;
        }
 
        cont = dir.GetNext(&filename);
    }
 
    // Recursively copy subdirectories
    cont = dir.GetFirst(&filename, wxEmptyString, wxDIR_DIRS);
    while (cont) {
        if (!filename.StartsWith(".")) {
            wxString sourceSubDir = sourcePath + wxFileName::GetPathSeparator() + filename;
            wxString destSubDir = destPath + wxFileName::GetPathSeparator() + filename;
 
            if (!CopyFolder(sourceSubDir, destSubDir)) {
                return false;
            }
        }
        cont = dir.GetNext(&filename);
    }
 
    LOG_INFO("FileExplorer",
             "Successfully copied folder: " + sourcePath.ToStdString() + " to " + destPath.ToStdString());
    return true;
}
 
bool FileExplorerTab::MoveFolder(const wxString &sourcePath, const wxString &destPath) {
    // Try simple rename first (works if on same filesystem)
    if (wxRenameFile(sourcePath, destPath, false)) {
        LOG_INFO("FileExplorer",
                 "Folder moved using rename: " + sourcePath.ToStdString() + " to " + destPath.ToStdString());
        return true;
    }
 
    // If rename fails, fall back to copy + delete
    LOG_INFO("FileExplorer", "Rename failed, using copy+delete for move operation");
 
    if (!CopyFolder(sourcePath, destPath)) {
        return false;
    }
 
    // Delete source after successful copy
    if (!DeleteFolder(sourcePath)) {
        wxMessageBox("Folder was copied but source could not be deleted", "Warning", wxOK | wxICON_WARNING, m_panel);
        LOG_WARNING("FileExplorer", "Move succeeded but source deletion failed: " + sourcePath.ToStdString());
        return true; // Still consider it success since copy worked
    }
 
    LOG_INFO("FileExplorer",
             "Successfully moved folder: " + sourcePath.ToStdString() + " to " + destPath.ToStdString());
    return true;
}
 
// ============================================================================
// File Operations
// ============================================================================
 
bool FileExplorerTab::RenameFile(const wxString &oldPath, const wxString &newName) {
    wxFileName fn(oldPath);
    wxString newPath = fn.GetPath() + wxFileName::GetPathSeparator() + newName;
 
    // Check if target already exists
    if (wxFileExists(newPath)) {
        wxMessageBox("A file with this name already exists", "Error", wxOK | wxICON_ERROR, m_panel);
        return false;
    }
 
    // Rename the file
    if (wxRenameFile(oldPath, newPath, false)) {
        LOG_INFO("FileExplorer",
                 "Renamed file from '" + oldPath.ToStdString() + "' to '" + newPath.ToStdString() + "'");
        LogActivity(ActivityType::RENAME_FILE, newPath, oldPath + "   ->   " + newPath);
        return true;
    } else {
        wxMessageBox("Failed to rename file. Check permissions.", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Failed to rename file: " + oldPath.ToStdString());
        return false;
    }
}
 
bool FileExplorerTab::DeleteFile(const wxString &filePath) {
    if (wxRemoveFile(filePath)) {
        LOG_INFO("FileExplorer", "Deleted file: " + filePath.ToStdString());
        LogActivity(ActivityType::DELETE_FILE, filePath, wxFileName(filePath).GetFullName());
        return true;
    } else {
        wxMessageBox("Failed to delete file. Check permissions or if file is in use.", "Error", wxOK | wxICON_ERROR,
                     m_panel);
        LOG_ERROR("FileExplorer", "Failed to delete file: " + filePath.ToStdString());
        return false;
    }
}
 
bool FileExplorerTab::CopyFile(const wxString &sourcePath, const wxString &destPath) {
    if (!wxFileExists(sourcePath)) {
        wxMessageBox("Source file does not exist", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Source file does not exist: " + sourcePath.ToStdString());
        return false;
    }
 
    if (wxCopyFile(sourcePath, destPath, false)) {
        LOG_INFO("FileExplorer",
                 "Successfully copied file: " + sourcePath.ToStdString() + " to " + destPath.ToStdString());
        return true;
    } else {
        wxMessageBox("Failed to copy file", "Error", wxOK | wxICON_ERROR, m_panel);
        LOG_ERROR("FileExplorer", "Failed to copy file: " + sourcePath.ToStdString());
        return false;
    }
}
 
bool FileExplorerTab::MoveFile(const wxString &sourcePath, const wxString &destPath) {
    // Try simple rename first (works if on same filesystem)
    if (wxRenameFile(sourcePath, destPath, false)) {
        LOG_INFO("FileExplorer",
                 "File moved using rename: " + sourcePath.ToStdString() + " to " + destPath.ToStdString());
        return true;
    }
 
    // If rename fails, fall back to copy + delete
    LOG_INFO("FileExplorer", "Rename failed, using copy+delete for file move operation");
 
    if (!CopyFile(sourcePath, destPath)) {
        return false;
    }
 
    // Delete source after successful copy
    if (!DeleteFile(sourcePath)) {
        wxMessageBox("File was copied but source could not be deleted", "Warning", wxOK | wxICON_WARNING, m_panel);
        LOG_WARNING("FileExplorer", "File move succeeded but source deletion failed: " + sourcePath.ToStdString());
        return true; // Still consider it success since copy worked
    }
 
    LOG_INFO("FileExplorer", "Successfully moved file: " + sourcePath.ToStdString() + " to " + destPath.ToStdString());
    return true;
}
 
void FileExplorerTab::ShowFileProperties(const wxString &filePath) {
    if (!wxFileExists(filePath)) {
        wxMessageBox("File does not exist", "Error", wxOK | wxICON_ERROR, m_panel);
        return;
    }
 
    wxFileName fn(filePath);
    wxString fileName = fn.GetFullName();
    wxString ext = fn.GetExt().Lower();
 
    // Get file information
    wxDateTime modTime, createTime;
    fn.GetTimes(nullptr, &modTime, &createTime);
 
    wxULongLong fileSize = fn.GetSize();
 
    // Build properties message
    wxString properties;
    properties += "File Properties\n";
    properties += "===============\n\n";
    properties += "Name: " + fileName + "\n";
    properties += "Type: " + (ext.IsEmpty() ? "File" : ext.Upper() + " File") + "\n";
    properties += "Location: " + fn.GetPath() + "\n";
    properties += "Full Path: " + filePath + "\n\n";
 
    // Format file size
    if (fileSize < 1024) {
        properties += wxString::Format("Size: %llu bytes\n", fileSize.GetValue());
    } else if (fileSize < 1024 * 1024) {
        properties +=
            wxString::Format("Size: %.2f KB (%llu bytes)\n", fileSize.ToDouble() / 1024.0, fileSize.GetValue());
    } else if (fileSize < 1024 * 1024 * 1024) {
        properties += wxString::Format("Size: %.2f MB (%llu bytes)\n", fileSize.ToDouble() / (1024.0 * 1024.0),
                                       fileSize.GetValue());
    } else {
        properties += wxString::Format("Size: %.2f GB (%llu bytes)\n", fileSize.ToDouble() / (1024.0 * 1024.0 * 1024.0),
                                       fileSize.GetValue());
    }
 
    properties += "\n";
 
    if (createTime.IsValid()) {
        properties += "Created: " + createTime.Format("%Y-%m-%d %H:%M:%S") + "\n";
    }
    if (modTime.IsValid()) {
        properties += "Modified: " + modTime.Format("%Y-%m-%d %H:%M:%S") + "\n";
    }
 
    // Show in a message box (could be a custom dialog for better UX)
    wxMessageBox(properties, "File Properties", wxOK | wxICON_INFORMATION, m_panel);
}
 
void FileExplorerTab::OpenFile(const wxString &filePath) {
    if (!wxFileExists(filePath)) {
        wxMessageBox("File does not exist", "Error", wxOK | wxICON_ERROR, m_panel);
        return;
    }
 
    wxString ext = wxFileName(filePath).GetExt().Lower();
 
    LOG_INFO("FileExplorer", "Opening file: " + filePath.ToStdString() + " (type: " + ext.ToStdString() + ")");
 
    // Log the activity
    LogActivity(ActivityType::OPEN_FILE, filePath, ext.Upper());
 
    // For now, just show a message that file opening is not yet implemented
    // TODO: Integrate with tab system to open files in appropriate editors
    wxString message = "File opening not yet implemented.\n\n";
    message += "File: " + wxFileName(filePath).GetFullName() + "\n";
    message += "Type: " + (ext.IsEmpty() ? "Unknown" : ext.Upper()) + "\n";
    message += "Path: " + filePath;
 
    wxMessageBox(message, "Open File", wxOK | wxICON_INFORMATION, m_panel);
 
    // Future implementation:
    // if (ext == "xml") {
    //     // Open in XML editor tab
    // } else if (ext == "png" || ext == "jpg" || ext == "jpeg") {
    //     // Open in image viewer tab
    // } else if (ext == "json") {
    //     // Open in JSON editor tab
    // } else {
    //     // Open with system default or text editor
    // }
}
 
// ============================================================================
// Navigation History Implementation
// ============================================================================
 
void FileExplorerTab::AddToNavigationHistory(const wxString &path) {
    // Add current path to back stack
    m_backStack.push_back(path);
 
    // Clear forward stack when navigating to a new location
    // (you can't go forward after branching to a new path)
    m_forwardStack.clear();
 
    // Optional: Limit history size to prevent excessive memory usage
    const size_t MAX_HISTORY_SIZE = 50;
    if (m_backStack.size() > MAX_HISTORY_SIZE) {
        m_backStack.erase(m_backStack.begin());
    }
 
    LOG_INFO("FileExplorer", "Added to navigation history: " + path.ToStdString() +
                                 " (back stack size: " + std::to_string(m_backStack.size()) + ")");
}
 
void FileExplorerTab::UpdateNavigationButtons() {
    // Check if buttons exist (might not be created yet during initialization)
    bool backEnabled = !m_backStack.empty();
    bool forwardEnabled = !m_forwardStack.empty();
 
    // Update grid/breadcrumb area buttons
    if (m_gridBackButton) {
        m_gridBackButton->Enable(backEnabled);
        if (backEnabled) {
            wxString backPath = m_backStack.back();
            m_gridBackButton->SetToolTip("Go Back to: " + backPath + " (Alt+Left)");
        } else {
            m_gridBackButton->SetToolTip("Go Back (Alt+Left)");
        }
    }
 
    if (m_gridForwardButton) {
        m_gridForwardButton->Enable(forwardEnabled);
        if (forwardEnabled) {
            wxString forwardPath = m_forwardStack.back();
            m_gridForwardButton->SetToolTip("Go Forward to: " + forwardPath + " (Alt+Right)");
        } else {
            m_gridForwardButton->SetToolTip("Go Forward (Alt+Right)");
        }
    }
}
 
void FileExplorerTab::OnBackButton(wxCommandEvent &event) {
    if (m_backStack.empty()) {
        return;
    }
 
    // Close history panel if it's open
    if (m_isHistoryVisible) {
        ToggleHistoryView();
    }
 
    // Get the previous path from back stack
    wxString previousPath = m_backStack.back();
    m_backStack.pop_back();
 
    // Add current path to forward stack
    m_forwardStack.push_back(m_currentGridPath);
 
    LOG_INFO("FileExplorer", "Navigating back to: " + previousPath.ToStdString());
 
    // Navigate without recording to history
    m_isNavigatingHistory = true;
    NavigateToPath(previousPath, false);
    m_isNavigatingHistory = false;
 
    // Update button states
    UpdateNavigationButtons();
}
 
void FileExplorerTab::OnForwardButton(wxCommandEvent &event) {
    if (m_forwardStack.empty()) {
        return;
    }
 
    // Close history panel if it's open
    if (m_isHistoryVisible) {
        ToggleHistoryView();
    }
 
    // Get the next path from forward stack
    wxString nextPath = m_forwardStack.back();
    m_forwardStack.pop_back();
 
    // Add current path to back stack
    m_backStack.push_back(m_currentGridPath);
 
    LOG_INFO("FileExplorer", "Navigating forward to: " + nextPath.ToStdString());
 
    // Navigate without recording to history
    m_isNavigatingHistory = true;
    NavigateToPath(nextPath, false);
    m_isNavigatingHistory = false;
 
    // Update button states
    UpdateNavigationButtons();
}
 
void FileExplorerTab::OnHistoryButton(wxCommandEvent &event) {
    // Toggle between history view and grid view
    ToggleHistoryView();
}
 
void FileExplorerTab::OnNavigationKeyDown(wxKeyEvent &event) {
    // Check for Alt+Left (Back) or Alt+Right (Forward)
    if (event.AltDown()) {
        if (event.GetKeyCode() == WXK_LEFT) {
            // Alt+Left: Go Back
            if (!m_backStack.empty()) {
                wxCommandEvent dummy;
                OnBackButton(dummy);
            }
            return;
        } else if (event.GetKeyCode() == WXK_RIGHT) {
            // Alt+Right: Go Forward
            if (!m_forwardStack.empty()) {
                wxCommandEvent dummy;
                OnForwardButton(dummy);
            }
            return;
        }
    }
 
    // Let other key events propagate
    event.Skip();
}
 
void FileExplorerTab::ToggleHistoryView() {
    if (!m_gridCtrl || !m_historyPanel || !m_contentSizer)
        return;
 
    m_isHistoryVisible = !m_isHistoryVisible;
 
    if (m_isHistoryVisible) {
        // Show history panel, hide grid
        LOG_INFO("FileExplorer", "Showing navigation history panel");
        m_gridCtrl->Hide();
        PopulateHistoryPanel();
        m_historyPanel->Show();
 
        // Update button appearance to show it's active
        if (m_historyButton) {
            m_historyButton->SetBackgroundColour(wxColour(60, 80, 110)); // Highlight color
        }
    } else {
        // Show grid, hide history panel
        LOG_INFO("FileExplorer", "Hiding navigation history panel");
        m_historyPanel->Hide();
        m_gridCtrl->Show();
 
        // Reset button appearance
        if (m_historyButton) {
            m_historyButton->SetBackgroundColour(wxColour(40, 40, 40)); // Normal color
        }
    }
 
    // Force layout update
    m_contentSizer->Layout();
    if (m_panel) {
        m_panel->Layout();
    }
}
 
void FileExplorerTab::PopulateHistoryPanel() {
    if (!m_historyPanel)
        return;
 
    // Helper function to format path with last 2 folders
    auto FormatShortPath = [](const wxString &fullPath) -> wxString {
        wxFileName pathFn(fullPath);
        wxArrayString dirs = pathFn.GetDirs();
        wxString filename = pathFn.GetFullName();
 
        wxString result = "..";
 
        if (!filename.IsEmpty()) {
            // It's a file - show last 2 parent directories + filename
            int startIdx = std::max(0, (int)dirs.GetCount() - 2);
            for (size_t i = startIdx; i < dirs.GetCount(); i++) {
                result += "/" + dirs[i];
            }
            result += "/" + filename;
        } else if (dirs.GetCount() > 0) {
            // It's a directory - show last 3 directories (including the target folder itself)
            int startIdx = std::max(0, (int)dirs.GetCount() - 3);
            for (size_t i = startIdx; i < dirs.GetCount(); i++) {
                result += "/" + dirs[i];
            }
        } else {
            // Fallback to full path if we can't parse it
            result = fullPath;
        }
 
        return result;
    };
 
    // Clear existing content properly
    // DestroyChildren will delete all child windows
    m_historyPanel->DestroyChildren();
 
    // If there's an existing sizer, wxWidgets will delete it when we set a new one
    // So we don't need to manually delete it
 
    // Main vertical sizer
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
 
    // Activity section header (fixed, doesn't scroll)
    wxPanel *activityHeaderPanel = new wxPanel(m_historyPanel, wxID_ANY);
    activityHeaderPanel->SetBackgroundColour(wxColour(50, 50, 50));
    wxBoxSizer *activityHeaderSizer = new wxBoxSizer(wxHORIZONTAL);
 
    wxStaticText *activityHeader = new wxStaticText(activityHeaderPanel, wxID_ANY, "Activity Log");
    activityHeader->SetForegroundColour(wxColour(200, 200, 200));
    wxFont activityHeaderFont = activityHeader->GetFont();
    activityHeaderFont.SetWeight(wxFONTWEIGHT_BOLD);
    activityHeader->SetFont(activityHeaderFont);
    activityHeaderSizer->Add(activityHeader, 0, wxALL, 8);
 
    activityHeaderPanel->SetSizer(activityHeaderSizer);
    mainSizer->Add(activityHeaderPanel, 0, wxEXPAND);
 
    // Activity scrollable content
    wxScrolledWindow *activityScrollWindow = new wxScrolledWindow(m_historyPanel, wxID_ANY);
    activityScrollWindow->SetBackgroundColour(wxColour(45, 45, 45));
    activityScrollWindow->SetScrollRate(0, 10);
 
    wxBoxSizer *activityContentSizer = new wxBoxSizer(wxVERTICAL);
 
    if (!m_activityHistory.empty()) {
 
        // Add recent activities (limit to 20)
        size_t activityCount = wxMin(m_activityHistory.size(), 20u);
        for (size_t i = 0; i < activityCount; i++) {
            const auto &activity = m_activityHistory[i];
 
            wxPanel *activityPanel = new wxPanel(activityScrollWindow, wxID_ANY);
            activityPanel->SetBackgroundColour(wxColour(45, 45, 45));
            wxBoxSizer *activitySizer = new wxBoxSizer(wxHORIZONTAL);
 
            // Action label based on activity type
            wxString actionLabel;
            wxColour labelColor;
            switch (activity.type) {
            case ActivityType::NAVIGATE:
                actionLabel = "[NAVIGATE]";
                labelColor = wxColour(100, 150, 200);
                break;
            case ActivityType::OPEN_FILE:
                actionLabel = "[OPEN]";
                labelColor = wxColour(150, 200, 150);
                break;
            case ActivityType::CREATE_FOLDER:
                actionLabel = "[CREATE]";
                labelColor = wxColour(100, 200, 100);
                break;
            case ActivityType::DELETE_FILE:
                actionLabel = "[DELETE FILE]";
                labelColor = wxColour(200, 100, 100);
                break;
            case ActivityType::DELETE_FOLDER:
                actionLabel = "[DELETE FOLDER]";
                labelColor = wxColour(200, 100, 100);
                break;
            case ActivityType::RENAME_FILE:
                actionLabel = "[RENAME FILE]";
                labelColor = wxColour(200, 180, 100);
                break;
            case ActivityType::RENAME_FOLDER:
                actionLabel = "[RENAME FOLDER]";
                labelColor = wxColour(200, 180, 100);
                break;
            case ActivityType::COPY:
                actionLabel = "[COPY]";
                labelColor = wxColour(150, 150, 200);
                break;
            case ActivityType::CUT:
                actionLabel = "[CUT]";
                labelColor = wxColour(200, 150, 100);
                break;
            case ActivityType::PASTE:
                actionLabel = "[PASTE]";
                labelColor = wxColour(150, 200, 200);
                break;
            }
 
            wxStaticText *actionText = new wxStaticText(activityPanel, wxID_ANY, actionLabel);
            actionText->SetForegroundColour(labelColor);
            wxFont actionFont = actionText->GetFont();
            actionFont.SetWeight(wxFONTWEIGHT_BOLD);
            actionText->SetFont(actionFont);
            activitySizer->Add(actionText, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 10);
 
            // Activity details
            wxString displayText;
 
            // For operations with details (rename, navigate, etc), format both paths
            if (!activity.details.IsEmpty() &&
                (activity.type == ActivityType::RENAME_FILE || activity.type == ActivityType::RENAME_FOLDER ||
                 activity.type == ActivityType::NAVIGATE || activity.type == ActivityType::PASTE)) {
                // Parse "before   ->   after" format (using ASCII arrow with 3 spaces)
                int arrowPos = activity.details.Find("   ->   ");
                if (arrowPos != wxNOT_FOUND) {
                    wxString beforePath = activity.details.Mid(0, arrowPos);
                    wxString afterPart = activity.details.Mid(arrowPos + 8); // Skip "   ->   "
 
                    // For paste operations, extract the path before "(moved)" or "(copied)"
                    wxString afterPath = afterPart;
                    wxString suffix = "";
                    int suffixPos = afterPart.Find(" (");
                    if (suffixPos != wxNOT_FOUND) {
                        afterPath = afterPart.Mid(0, suffixPos);
                        suffix = afterPart.Mid(suffixPos); // Keep " (moved)" or " (copied)"
                    }
 
                    displayText = FormatShortPath(beforePath) + "   ->   " + FormatShortPath(afterPath) + suffix;
                } else {
                    displayText = activity.details;
                }
            } else {
                // Show short path for all other operations
                displayText = FormatShortPath(activity.path);
            }
 
            // Check if we need to color the arrow green
            int displayArrowPos = displayText.Find("   ->   ");
            if (displayArrowPos != wxNOT_FOUND) {
                // Split into three parts: before, arrow, after
                wxString beforeText = displayText.Mid(0, displayArrowPos);
                wxString afterText = displayText.Mid(displayArrowPos + 8); // Skip "   ->   "
 
                // Create a horizontal sizer for the text parts
                wxBoxSizer *textSizer = new wxBoxSizer(wxHORIZONTAL);
 
                // Before text
                wxStaticText *textBefore = new wxStaticText(activityPanel, wxID_ANY, beforeText);
                textBefore->SetForegroundColour(wxColour(200, 200, 200));
                textSizer->Add(textBefore, 0, wxALIGN_CENTER_VERTICAL);
 
                // Arrow (green)
                wxStaticText *arrowText = new wxStaticText(activityPanel, wxID_ANY, "   ->   ");
                arrowText->SetForegroundColour(wxColour(100, 255, 100)); // Bright green
                textSizer->Add(arrowText, 0, wxALIGN_CENTER_VERTICAL);
 
                // After text
                wxStaticText *textAfter = new wxStaticText(activityPanel, wxID_ANY, afterText);
                textAfter->SetForegroundColour(wxColour(200, 200, 200));
                textSizer->Add(textAfter, 0, wxALIGN_CENTER_VERTICAL);
 
                activitySizer->Add(textSizer, 1, wxEXPAND | wxRIGHT, 10);
            } else {
                // No arrow, use single text widget
                wxStaticText *text = new wxStaticText(activityPanel, wxID_ANY, displayText, wxDefaultPosition,
                                                      wxDefaultSize, wxST_NO_AUTORESIZE);
                text->SetForegroundColour(wxColour(200, 200, 200));
                text->Wrap(900); // Wrap text at 900 pixels to utilize full width
                activitySizer->Add(text, 1, wxEXPAND | wxRIGHT, 10);
            }
 
            // Timestamp
            wxString timeStr = activity.timestamp.Format("%H:%M:%S");
            wxStaticText *timeText = new wxStaticText(activityPanel, wxID_ANY, timeStr);
            timeText->SetForegroundColour(wxColour(120, 120, 120));
            wxFont timeFont = timeText->GetFont();
            timeFont.SetPointSize(timeFont.GetPointSize() - 1);
            timeText->SetFont(timeFont);
            activitySizer->Add(timeText, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 10);
 
            activityPanel->SetSizer(activitySizer);
            activityPanel->Layout(); // Force layout to calculate wrapped text size
            activityPanel->Fit();    // Fit the panel to its content size
            // Show full paths in tooltip - details for rename/paste, path otherwise
            wxString tooltip = activity.details.IsEmpty() ? activity.path : activity.details;
            activityPanel->SetToolTip(tooltip);
 
            // Hover effect for clickable activities
            if (activity.type == ActivityType::NAVIGATE || activity.type == ActivityType::OPEN_FILE) {
                wxString pathCopy = activity.path;
 
                activityPanel->Bind(wxEVT_ENTER_WINDOW, [](wxMouseEvent &evt) {
                    wxWindow *win = dynamic_cast<wxWindow *>(evt.GetEventObject());
                    if (win) {
                        win->SetBackgroundColour(wxColour(60, 80, 110));
                        win->Refresh();
                    }
                });
 
                activityPanel->Bind(wxEVT_LEAVE_WINDOW, [](wxMouseEvent &evt) {
                    wxWindow *win = dynamic_cast<wxWindow *>(evt.GetEventObject());
                    if (win) {
                        win->SetBackgroundColour(wxColour(45, 45, 45));
                        win->Refresh();
                    }
                });
 
                if (activity.type == ActivityType::NAVIGATE && wxDirExists(pathCopy)) {
                    activityPanel->Bind(wxEVT_LEFT_DOWN, [this, pathCopy](wxMouseEvent &) {
                        if (m_panel) {
                            NavigateToPath(pathCopy);
                            ToggleHistoryView();
                        }
                    });
                }
            }
 
            activityContentSizer->Add(activityPanel, 0, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 3);
        }
    } else {
        // Show empty message for activities
        wxStaticText *emptyText =
            new wxStaticText(activityScrollWindow, wxID_ANY, "No activities yet.\nPerform actions to see history.");
        emptyText->SetForegroundColour(wxColour(150, 150, 150));
        activityContentSizer->Add(emptyText, 0, wxALL | wxALIGN_CENTER, 20);
    }
 
    // Set sizer for activity scroll window and fit its virtual size
    activityScrollWindow->SetSizer(activityContentSizer);
    activityScrollWindow->FitInside();
 
    // Add scroll window directly to main sizer
    mainSizer->Add(activityScrollWindow, 1, wxEXPAND);
 
    m_historyPanel->SetSizer(mainSizer);
    m_historyPanel->FitInside();
    m_historyPanel->Refresh();
}
 
void FileExplorerTab::LogActivity(ActivityType type, const wxString &path, const wxString &details) {
    ActivityEntry entry;
    entry.type = type;
    entry.path = path;
    entry.details = details;
    entry.timestamp = wxDateTime::Now();
 
    // Add to front (most recent first)
    m_activityHistory.insert(m_activityHistory.begin(), entry);
 
    // Limit size to prevent unbounded growth
    if (m_activityHistory.size() > MAX_ACTIVITY_ENTRIES) {
        m_activityHistory.resize(MAX_ACTIVITY_ENTRIES);
    }
 
    // Log the activity
    wxString activityName;
    switch (type) {
    case ActivityType::NAVIGATE:
        activityName = "Navigate";
        break;
    case ActivityType::OPEN_FILE:
        activityName = "Open";
        break;
    case ActivityType::CREATE_FOLDER:
        activityName = "Create Folder";
        break;
    case ActivityType::DELETE_FILE:
        activityName = "Delete File";
        break;
    case ActivityType::DELETE_FOLDER:
        activityName = "Delete Folder";
        break;
    case ActivityType::RENAME_FILE:
        activityName = "Rename File";
        break;
    case ActivityType::RENAME_FOLDER:
        activityName = "Rename Folder";
        break;
    case ActivityType::COPY:
        activityName = "Copy";
        break;
    case ActivityType::CUT:
        activityName = "Cut";
        break;
    case ActivityType::PASTE:
        activityName = "Paste";
        break;
    }
 
    LOG_INFO("FileExplorer", "Activity: " + activityName.ToStdString() + " - " + path.ToStdString());
}